;;; php-completion.el -- complete everything PHP with Anything.el

;; Copyright (C) 2009 KAYAC Inc. All rights reserved.

;; Author: IMAKADO <ken.imakado@gmail.com>
;; blog: http://d.hatena.ne.jp/IMAKADO (japanese)
;; Prefix: phpcmp-

;; This file is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.

;; This file is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.

;;; log:

;; ver 0.03
;;   * IMAKADO:
;;      * candidates from TAGS file.
;;      * added some commands.
;;      * refactoring

;; ver 0.02
;;   * IMAKADO:
;;      * candidates from GLOBAL tag files.


;;; Commentary:

;; complete php functions, symbols, ini directives, keywords with Anything.el's Interface.

;;; Commands:
;;
;; Below are complete command list:
;;
;;
;;; Customizable Options:
;;
;; Below are customizable option list:
;;
;;  `phpcmp-browse-function'
;;    called with one argment URL
;;    default is (quote browse-url)
;;  `phpcmp-manual-url-format'
;;    `%s' is replaced to query.
;;    default = (cond ((ignore-errors ...) "http://jp2.php.net/manual-lookup.php?lang=ja&pattern=%s") (t "http://jp2.php.net/manual-lookup.php?lang=en&pattern=%s"))
;;  `phpcmp-lighter'
;;    value is displayed in the modeline when the php-completion-mode is on.
;;    default = " Completion"
;;  `phpcmp-global-enable-auto-update-tag-files'
;;    If value is non-nil, automatically update GNU global's tag files.
;;    default = nil
;;  `phpcmp-showtip-timeout'
;;    Seconds to wait before displaying a tooltip the first time.
;;    default = 10
;;  `phpcmp-showtip-top-adjust'
;;    Basic adjust.
;;    default = 40

;; Installation:
;;
;; put `php-completion.el' somewhere in your emacs load path.
;; add these lines to your .emacs file:
;; -------------- .emacs -----------------------------
;; (add-hook 'php-mode-hook
;;           (lambda ()
;;             (require 'php-completion)
;;             (php-completion-mode t)
;;             (define-key php-mode-map (kbd "C-o") 'phpcmp-complete)))
;; ---------------------------------------------------

;; Cooperation with auto-complete.el:
;;
;; add these lines to your .emacs file:
;; (add-hook  'php-mode-hook
;;            (lambda ()
;;              (when (require 'auto-complete nil t)
;;                (make-variable-buffer-local 'ac-sources)
;;                (add-to-list 'ac-sources 'ac-source-php-completion)
;;                ;; if you like patial match,
;;                ;; use `ac-source-php-completion-patial' instead of `ac-source-php-completion'.
;;                ;; (add-to-list 'ac-sources 'ac-source-php-completion-patial)
;;                (auto-complete-mode t))))

;; Features that might be required by this library:
;;
;; `cl' `rx' `browse-url' `url-util' `etags' `thingatpt'
;; `anything' `anything-match-plugin' `auto-complete' `pp'
;;

(require 'cl)
(require 'rx)
(require 'browse-url)
(require 'url-util)
(require 'etags)
(require 'thingatpt)

(require 'anything)
(require 'anything-match-plugin)
(require 'auto-complete)

(defvar phpcmp-version 0.03)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Customize Variables ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defgroup php-completion nil
  "php-completion"
  :group 'php-completion)

(defcustom phpcmp-browse-function 'browse-url
  "called with one argment URL"
  :group 'php-completion
  :type 'function)

(defcustom phpcmp-manual-url-format
  (cond
   ((ignore-errors
      (string= current-language-environment "Japanese"))
    "http://jp2.php.net/manual-lookup.php?lang=ja&pattern=%s")
   (t
    "http://jp2.php.net/manual-lookup.php?lang=en&pattern=%s"
    ))
  "`%s' is replaced to query.
see `phpcmp-search-url'"
  :group 'php-completion
  :type 'string)

(defcustom phpcmp-lighter " Completion"
  "value is displayed in the modeline when the php-completion-mode is on."
  :group 'php-completion
  :type 'string)

(defcustom phpcmp-global-enable-auto-update-tag-files nil
  "If value is non-nil, automatically update tag files."
  :group 'php-completion
  :type 'boolean)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Variables ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar phpcmp-identifier-regexp "[a-zA-Z_][a-zA-Z_0-9]*")

;; etags
(defvar phpcmp-etags-tag-file-name "TAGS")
(defvar phpcmp-etags-tag-file-search-limit 10)
(defvar phpcmp-etags-completions-table nil
  "alist, ((name . (list of candidates))
           (name . (list of candidates))
           ...)")


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Hooks ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar phpcmp--initialize-hook nil
  "run when invoke completion command")

(defvar phpcmp-obj-instance-of-module-maybe-alist nil)

(add-hook 'phpcmp--initialize-hook
          (lambda ()
            (setq phpcmp-obj-instance-of-module-maybe-alist
                  (phpcmp-get-obj-instance-of-module-maybe-alist))))

(defun phpcmp-get-obj-instance-of-module-maybe-alist ()
  (let* ((re (rx-to-string `(and (group
                                  "$" ;1 var name
                                  (regexp ,phpcmp-identifier-regexp))
                                 (* space)
                                 "="
                                 (* space)
                                 "new"
                                 (+ space)
                                 (group
                                  (regexp ,phpcmp-identifier-regexp))))))
    (save-excursion
      (loop initially (goto-char (point-min))
            while (re-search-forward re nil t)
            collect `(,(match-string-no-properties 1) . ,(match-string-no-properties 2))))))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Structure ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Struct `phpcmp-tag'
;; tag-file: TAGS file path

;; path: fileのfullpath

;; classes:
;; list of Struct `phpcmp-class'

;; functions: list of functions

;; variables: list of variables
(defstruct (phpcmp-tag
            (:constructor phpcmp-make-tag
                          (&key tag-file path relative-path classes functions variables)))
  tag-file path relative-path classes functions variables)

(defstruct (phpcmp-class
            (:constructor phpcmp-make-class
                          (&key name parent methods variables)))
  name parent methods variables)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Log ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar phpcmp-debug nil)
(defsubst phpcmp-log-buf ()
  (get-buffer-create "*php-completion debug*"))

(defsubst phpcmp-log-insert (type-str &rest messages)
  (ignore-errors
    (let* ((str (or (ignore-errors (apply 'format messages))
                    (pp-to-string (car messages))))
           (str (concat type-str str "\n")))
      (with-current-buffer (phpcmp-log-buf)
          (goto-char (point-max))
          (insert str)))))

(defsubst phpcmp-log (type &rest messages)
  (ignore-errors
    (when phpcmp-debug
      (require 'pp)
      (case type
        (info (apply 'phpcmp-log-insert "info: " messages))
        (debug (unless (eq phpcmp-debug 'info)
                 (apply 'phpcmp-log-insert "debug: " messages)))))))

(defsubst phpcmp-log-info (&rest messages)
  (apply 'phpcmp-log 'info messages))

(defsubst phpcmp-log-debug (&rest messages)
  (apply 'phpcmp-log 'debug messages))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Utilities ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defsubst phpcmp-get-current-directory ()
  (file-name-directory
   (expand-file-name
    (or (buffer-file-name)
        default-directory))))

(defsubst phpcmp-tramp-p ()
  (when (and (featurep 'tramp)
             (fboundp 'tramp-tramp-file-p))
    (tramp-tramp-file-p (phpcmp-get-current-directory))))

(defun* phpcmp-collect-matches
    (re &optional (count 0) (match-string-fn 'match-string)
        (point-min (point-min)) (point-max (point-max)))
  (save-excursion
    (loop initially (goto-char point-min)
          while (re-search-forward re point-max t)
          collect (funcall match-string-fn count))))

(defun* phpcmp-async-do
    (&key command args buffer-name
          (callback 'identity)
          (errorback (lambda() (message (buffer-string)))))
  (lexical-let ((buf (get-buffer-create buffer-name))
                (callback callback)
                (errorback errorback))
    (lexical-let
      ((sentinel (lambda (proc event)
         (cond ((and (string= event "finished\n")
                     (= (process-exit-status proc) 0))
                (with-current-buffer buf
                  (funcall callback))
                (ignore-errors
                    (kill-buffer buf)))
               ((and (string= event "finished\n")
                     (/= (process-exit-status proc) 0))
                (with-current-buffer buf
                  (funcall errorback)))))))
      (set-process-sentinel (apply 'start-process command buf command args) sentinel))))

(defsubst phpcmp-preceding-line-string ()
  (or (ignore-errors (buffer-substring-no-properties (point-at-bol) (point)))
      ""))

(defsubst* phpcmp-preceding-string (&optional (n 1))
  (buffer-substring-no-properties
   (point)
   (or (ignore-errors
         (save-excursion
           (backward-char n)
           (point)))
       (point))))

(defun phpcmp-remove-dups (los)
  "fast remove-duplicates"
  (let ((hash (make-hash-table :test 'equal))
        (ret nil))
    (loop for s in los
          do (puthash s nil hash))
    (maphash (lambda (k v) (push k ret)) hash)
    ret))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Candidates from php command ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; silence compiler
;; (defun phpcmp-get-functions () ())
(defun phpcmp-async-set-functions () ())

(defvar phpcmp-get-functions-async-buffer-name "*php-completion functions*")
(lexical-let (set-functions-done)
  (defun phpcmp-async-set-functions ()
    (unless set-functions-done
      (let* ((buf-name phpcmp-get-functions-async-buffer-name)
             (process-running? (eq 'run
                                   (let ((proc (get-buffer-process buf-name)))
                                     (when (processp proc)
                                       (process-status proc)))))
             (php-command (executable-find "php")))
        (when (and (not (phpcmp-tramp-p))
                   (not process-running?)
                   php-command)
          (phpcmp-async-do
           :buffer-name buf-name
           :command php-command
           :args '("-r"
                   "foreach (get_defined_functions() as $vars) { foreach ($vars as $var) {echo \"$var\n\";}}")
           :callback (lambda ()
                       (let ((los (phpcmp-collect-matches "[[:print:]]+")))
                         (phpcmp-db-update 'functions los)
                         (setq set-functions-done t))))))))
  (defun phpcmp-get-functions ()
    (prog1 (phpcmp-db-get 'functions)
      (unless set-functions-done
        (phpcmp-async-set-functions)))))



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Completion ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar phpcmp-initial-input nil)
(defun phpcmp-get-initial-input ()
  (setq phpcmp-initial-input
        (buffer-substring-no-properties (point)
                                        (progn (save-excursion
                                                 (skip-syntax-backward "w_")
                                                 (point))))))

(defvar phpcmp--smart-sort-rules nil)
(defun phpcmp-add-smart-sort-rule (detector regexps-or-fn)
  ""
  (add-to-list 'phpcmp--smart-sort-rules (list detector regexps-or-fn)))

(defun phpcmp-smart-sort (table)
  ;; silence compiler
  (declare (special detector))
  (let ((do-sort (lambda (regexps-or-fn ret-detector)
                   (cond
                    ((functionp regexps-or-fn)
                     (if ret-detector
                         (funcall regexps-or-fn table ret-detector)
                       (error "phpcmp-smart-sort: regexps-or-fn is function. but detector returns nil.\n: %S"
                              detector)))
                    ((or (stringp regexps-or-fn)
                         (consp regexps-or-fn))
                     (phpcmp-re-sort-table regexps-or-fn table))
                    (t
                     (error "phpcmp-smart-sort: must not error!!"))))))
    (loop for (detector regexps-or-fn) in phpcmp--smart-sort-rules
          with ret-detector
          when (and (functionp detector)
                    (save-excursion
                      (setq ret-detector (funcall detector))))
          do (setq table
                   (condition-case e
                       (funcall do-sort regexps-or-fn ret-detector)
                     (error (phpcmp-log-debug (error-message-string e))
                            table)))
          finally return table)))

(defvar phpcmp-get-words-in-buffer-regexp
  (rx (>= 3 (or (syntax word)
                (syntax symbol)))))

(defun phpcmp-get-words-in-buffer ()
  (let ((cur-point (point))
        (ret nil))
    (save-excursion
      ;; search backward
      (goto-char (point-min))
      (loop always (re-search-forward phpcmp-get-words-in-buffer-regexp cur-point t)
            do (push (match-string-no-properties 0) ret))
      ;; search forward
      (goto-char cur-point)
      (loop always (re-search-forward phpcmp-get-words-in-buffer-regexp nil t)
            do (push (match-string-no-properties 0) ret)))
    ;; return
    (nreverse ret)))

(defun phpcmp-completions-table ()
  "list of list(name get-candidates-funcion)"
  (let* ((table '(("words in buffer" (lambda ()
                                      (phpcmp-get-words-in-buffer)))
                 ("functions" (lambda ()
                                (phpcmp-get-functions)))
                 ("ini directives" (lambda ()
                                     (phpcmp-db-get 'ini-directives)))
                 ("constants" (lambda ()
                                (phpcmp-db-get 'constants)))
                 ("keywords" (lambda ()
                               (phpcmp-db-get 'keywords)))
                 ("superglobals" (lambda ()
                                   (phpcmp-db-get 'superglobals)))
                 ("types" (lambda ()
                            (phpcmp-db-get 'types)))
                 ("global tags" (lambda ()
                                  (phpcmp-global-get-tags)))
                 ("global symbols" (lambda ()
                                     (phpcmp-global-get-symbols)))))
         (table (append table phpcmp-etags-completions-table)))
    (run-hooks 'phpcmp--initialize-hook)
    (phpcmp-smart-sort table)))

(defun phpcmp-re-sort-table (regexps table &optional reverse)
  (condition-case e
      (lexical-let*
          ((make-list (lambda (a) (if (consp a) a (list a))))
           (regexps (funcall make-list regexps))
           (any-match? (lambda (list)
                         (let ((name (first list)))
                           (some (lambda (re)
                                   (string-match re name))
                                 regexps)))))
        (phpcmp-log-info "called phpcmp-re-sort-table regexps:%s" regexps)
        (loop for list in table
              if (funcall any-match? list)
              collect list into matches
              else
              collect list into unmaches
              finally return (if reverse
                                 (nconc unmaches matches)
                               (nconc matches unmaches))))
    (error table)))

(defun phpcmp-make-completion-sources ()
  (labels ((make-source (&key name candidates)
            `((name . ,name)
              (init . (lambda ()
                        (with-current-buffer (anything-candidate-buffer 'global)
                          (insert (mapconcat 'identity
                                             (if (functionp ',candidates)
                                                 (funcall ',candidates)
                                               ',candidates)
                                             "\n")))))
              (candidates-in-buffer)
              (action . (("Insert" . (lambda (candidate)
                                       (delete-backward-char (length phpcmp-initial-input))
                                       (insert candidate)))
              ("Search". (lambda (candidate)
                           (phpcmp-search-manual candidate))))))))
    (loop for (name candidates) in (phpcmp-completions-table)
          collect (make-source
                   :name name
                   :candidates candidates))))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Define Smart Completion Rule ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Class::function`!!'
(defun phpcmp-smart-sort-rule-full-name ()
  (backward-sexp)
  (let ((s (phpcmp-preceding-line-string)))
    (when (string-match (rx-to-string `(and (group (regexp ,phpcmp-identifier-regexp)) "::" eol))
                        s)
      (let ((s (match-string 1 s)))
        (prog1 s
          (phpcmp-log-info "sort-rule: full name call. returns %s" s))))))

(phpcmp-add-smart-sort-rule
 'phpcmp-smart-sort-rule-full-name
 (lambda (completion-table class-name) ; `phpcmp-smart-sort-rule-full-name' returns class-name
   (phpcmp-re-sort-table class-name completion-table)))

(phpcmp-add-smart-sort-rule
 (lambda ()
   (backward-sexp)
   (eq (preceding-char) ?$))
 "variable")

;;; $this->`!!'
(phpcmp-add-smart-sort-rule
 (lambda ()
   (backward-sexp)
   (let ((s (phpcmp-preceding-string 2)))
     (string= s "->")))
 "method")


;;; $var`!!'
(defun phpcmp-smart-sort-variable ()
  (interactive)
  (backward-sexp)
  (let ((s (phpcmp-preceding-string 1)))
    (when (and (stringp s)
               (string= s "$"))
      s)))

(phpcmp-add-smart-sort-rule
 'phpcmp-smart-sort-variable
 "variable")


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Document ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun phpcmp-search-manual (query)
  (let ((url (phpcmp-search-url query)))
    (funcall phpcmp-browse-function url)))


(defun phpcmp-search-url (query)
  (format phpcmp-manual-url-format
          (url-hexify-string query)))

(defun phpcmp-get-document-string (s)
  (cond
   ((executable-find "w3m")
    (let ((url (phpcmp-search-url s)))
      (let ((coding-system-for-write 'utf-8)
            (coding-system-for-read 'utf-8))
        (let ((docstring (shell-command-to-string (format "w3m -dump %s" (shell-quote-argument (phpcmp-search-url s))))))
          (phpcmp-take-document docstring)))))
   (t
    "can't find \"w3m\" command")))

(defun phpcmp-take-document (docstring)
  (with-temp-buffer
    (cond
     ((stringp docstring)
      (insert docstring)
      (goto-char (point-min))
      (re-search-forward (rx bol "説明") nil t)
      (buffer-substring-no-properties (point-at-bol) (point-max)))
     (t
      ""))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DB ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar phpcmp--db (make-hash-table)
  "hash table.
'functions -> list of function
'variables -> list of variable
'class -> `phpcmp--db-class'")

(defvar phpcmp--db-class (make-hash-table :test 'equal)
  "String class-name -> Struct `phpcmp-class'")

;; (phpcmp-db-get 'functions)
;; (phpcmp-db-get 'variables)
;; (phpcmp-db-get 'ini-directives) ini
;; (phpcmp-db-get 'constants) constants
;; (phpcmp-db-get 'keywords) keywords
;; (phpcmp-db-get 'superglobals) superglobals
;; (phpcmp-db-get 'types) types
;; (phpcmp-db-get 'class "class-name" 'methods)
;; (phpcmp-db-get 'class "class-name" 'variables)
(defun phpcmp-db-get (type &rest args)
  (case type
    (class (apply 'phpcmp-db-get-class args))
    (otherwise (apply 'phpcmp--db-get-otherwise type args))))

(defun phpcmp--db-get-class (class-name type)
  (let ((phpcmp-class (gethash (downcase class-name) phpcmp--db-class)))
    (when (phpcmp-class-p phpcmp-class)
      (ecase type
        (methods (append (phpcmp-class-methods phpcmp-class)
                         ;; parent class
                         (let ((parent-class (phpcmp-class-parent phpcmp-class)))
                           (phpcmp--db-get-class parent-class 'methods))))
        (variables (append (phpcmp-class-variables phpcmp-class)
                           (let ((parent-class (phpcmp-class-parent phpcmp-class)))
                             (phpcmp--db-get-class parent-class 'variables))))))))

(defun phpcmp--db-get-otherwise (key)
  (gethash key phpcmp--db))

(defun phpcmp-db-update (type &rest args)
  (case type
    (class (apply 'phpcmp--db-update-class args))
    (otherwise (apply 'phpcmp--db-update-otherwise type args))))

(defun phpcmp--db-update-class (phpcmp-class)
  "`phpcmp-class' -> do update DB"
  (assert (phpcmp-class-p phpcmp-class))
  (let ((name (phpcmp-class-name phpcmp-class)))
    (and name
         (stringp name)
         ;; downcase name. case-insensitive.
         (puthash (downcase name) phpcmp-class phpcmp--db-class))))

(defun phpcmp--db-update-otherwise (key values)
  (let ((cur-val (gethash key phpcmp--db)))
    (puthash key (phpcmp-remove-dups (append cur-val values)) phpcmp--db)))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; GLOBAL ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun phpcmp-global-execute-command (option)
  (let ((global-cmd (executable-find "global"))
        (tags-not-found? (lambda (los)
                           (and (stringp (car los))
                                (string= "global: GTAGS not found." (car los))))))
    (when phpcmp-global-enable-auto-update-tag-files
      (phpcmp-global-auto-update-tag-files))
    (when global-cmd
      (with-temp-buffer
        (call-process "global" nil t nil option)
        (let ((los (phpcmp-collect-matches "[[:print:]]+")))
          (unless (funcall tags-not-found? los)
            los))))))

(defun phpcmp-global-get-symbols ()
  (phpcmp-global-execute-command "-cs"))

(defun phpcmp-global-get-tags ()
  (phpcmp-global-execute-command "-c"))


(defun phpcmp-global-auto-update-tag-files ()
  (lexical-let* ((global-cmd (executable-find "global"))
                 (buf-name " *php-completion GLOBAL update*")
                 (process-running? (eq 'run
                                       (let ((proc (get-buffer-process buf-name)))
                                         (when (processp proc)
                                           (process-status proc))))))
    (when (and global-cmd
               (not process-running?))
      (phpcmp-async-do
       :command global-cmd
       :args '("-u")
       :buffer-name buf-name
       :callback (lambda ()
                   (kill-buffer buf-name))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Etags ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;; this function is copied from anything-etags.el

(defun phpcmp-etags-find-tag-file ()
  "Find TAGS file, if can't find TAGS file in same directory, `phpcmp-etags-find-tag-file' try to find upper directory.
`phpcmp-etags-tag-file-search-limit' is limit number to find. default 10

Return tags file(full path).
If file is not found, return nil"
  (let ((file-exists? (lambda (dir)
                        (let ((tag-path (concat dir phpcmp-etags-tag-file-name)))
                          (and (stringp tag-path)
                               (file-exists-p tag-path)
                               (file-readable-p tag-path)))))
        (current-dir (phpcmp-get-current-directory)))
    (ignore-errors
      (loop with count = 0
            until (funcall file-exists? current-dir)
            ;; Return nil if outside the value of
            ;; `phpcmp-etags-tag-file-search-limit'.
            if (= count phpcmp-etags-tag-file-search-limit)
            do (return nil)
            ;; Or search upper directories.
            else
            do (progn (incf count)
                      (setq current-dir (expand-file-name (concat current-dir "../"))))
            finally return (concat current-dir phpcmp-etags-tag-file-name)))))

(defun* phpcmp-etags-get-tags (&optional (tag-file (phpcmp-etags-find-tag-file)))
  "Return list of struct `phpcmp-tag'"
  (when (and (stringp tag-file)
             (file-exists-p tag-file)
             (file-readable-p tag-file))
    (with-temp-buffer
      (insert-file-contents tag-file)
      (phpcmp-etags-parse-tags-buffer tag-file))))

(defun* phpcmp-etags-update-db (&optional (tags (phpcmp-etags-get-tags)))
  (let ((update-class (lambda (phpcmp-tag)
                        (loop for phpcmp-class in (phpcmp-tag-classes phpcmp-tag)
                              when (phpcmp-class-p phpcmp-class)
                              do (phpcmp-db-update 'class phpcmp-class))))
        (update-functions (lambda (phpcmp-tag)
                            (phpcmp-db-update 'functions
                                              (phpcmp-tag-functions phpcmp-tag))))
        (update-variables (lambda (phpcmp-tag)
                            (phpcmp-db-update 'variables (phpcmp-tag-variables phpcmp-tag)))))
    (mapc (lambda (tag)
            (funcall update-class tag)
            (funcall update-functions tag)
            (funcall update-variables tag))
          tags)))

(defun phpcmp-build-class-alist (class)
  (when (phpcmp-class-p class)
    (let ((name (phpcmp-class-name class))
          (methods (phpcmp-class-methods class))
          (variables (phpcmp-class-variables class)))
      `((,(concat name " methods") ,methods)
        (,(concat name " variables") ,variables)))))

(defun phpcmp-build-class-alist-from-tag (tag)
  (when (phpcmp-tag-p tag)
    (let ((classes (phpcmp-tag-classes tag)))
      (loop for class in classes
            append (phpcmp-build-class-alist class)))))

(defun phpcmp-tags-to-alist (tags)
  "list of `phpcmp-tag' to alist"
  (loop for tag in tags
        append (phpcmp-build-class-alist-from-tag tag)))

(defun phpcmp-set-etags-alist (tags)
  (setq phpcmp-etags-completions-table
        (nconc phpcmp-etags-completions-table (phpcmp-tags-to-alist tags))))



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Etags: TAGS Parser ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; This monster regexp matches an etags tag line.
;;   \1 is the string to match;
;;   \2 is not interesting;
;;   \3 is the guessed tag name; XXX guess should be better eg DEFUN
;;   \4 is not interesting;
;;   \5 is the explicitly-specified tag name.
;;   \6 is the line to start searching at;
;;   \7 is the char to start searching at.
(defvar phpcmp-etags-parse-tags-file-regexp
  (rx bol
      (group                                             ;1
       (regexp "\\([^\177]+[^-a-zA-Z0-9_+*$:\177]+\\)?") ;2
       (regexp "\\([-a-zA-Z0-9_+*$?:]+\\)")              ;3
       (regexp "[^-a-zA-Z0-9_+*$?:\177]*"))
      "\177"
      (regexp "\\(\\([^\n\001]+\\)\001\\)?") ;4, 5

      (regexp "\\([0-9]+\\)?")               ;6
      ","
      (regexp "\\([0-9]+\\)?")               ;7
      "\n"
      ))


(defsubst phpcmp-deftag (tag-string tag-file)
  (with-temp-buffer
    (insert tag-string)
    (goto-char (point-min))
    ;; Return struct `phpcmp-tag'
    (phpcmp-deftag-parse tag-file)))

(defun phpcmp-etags-parse-tags-buffer (tag-file)
  (let ((each-file-tag-strings
         (delete "" (split-string (buffer-string) "\14[ \n]+"))))
    (loop for s in each-file-tag-strings
          collect (phpcmp-deftag s tag-file))))


(defsubst phpcmp-deftag-parse-file-info ()
  (when (looking-at (rx bol (group (+ (not (any ",")))) "," (? (* digit)) "\n"))
    (let* ((relative-file-path (match-string 1)))
      (prog1 relative-file-path
        (forward-line)))))

(defsubst phpcmp-take-same-indent-string ()
  "move point"
  (let ((cur-indent (current-indentation))
        (cur-point (point)))
    (forward-line)
    (buffer-substring-no-properties
     cur-point
     (loop while (and
                  (not
                   (>= cur-indent
                       (current-indentation)))
                  (not (eobp)))
           do (forward-line)
           finally return (point)))))

(defsubst phpcmp-deftag-parse-class ()
  (let ((class-str (phpcmp-take-same-indent-string))
        name parent methods variables)
    (with-temp-buffer
      (insert class-str)
      (goto-char (point-min))
      (while (not (eobp))
        (cond
         ((looking-at (rx bol (* space) "class" (? (*? not-newline) "extends" (+ space) (group (+ (any alpha "_"))))))
          (let ((parent-class (match-string 1)))
            (when parent-class
              (setq parent parent-class)))
          (when (looking-at phpcmp-etags-parse-tags-file-regexp)
            (let ((class-name (match-string 5)))
              (setq name class-name)))
          (forward-line))
         ((looking-at (rx bol (* space) (? (or "public" "private")) (* space) "function"))
          (when (looking-at phpcmp-etags-parse-tags-file-regexp)
            (let ((function (match-string 5)))
              (push function methods)))
          (forward-line))
         ((looking-at (rx bol (* space) "$" (+ (any alnum "_")) (* space) "="))
          (when (looking-at phpcmp-etags-parse-tags-file-regexp)
            (let ((variable (match-string 5)))
              (push variable variables)))
          (forward-line))
         (t
          (forward-line)))))
    (phpcmp-make-class
     :name name
     :parent parent
     :methods methods
     :variables variables)))



(defun phpcmp-deftag-parse (tag-file)
  (let ((relative-file-path (phpcmp-deftag-parse-file-info)))
    (let (path relative-path classes functions variables)
      (while (not (eobp))
        (cond
         ((looking-at (rx bol (* space) "class"))
          (push (phpcmp-deftag-parse-class) classes))
         ((looking-at (rx bol (* space) (? (or "public" "private")) (* space) "function"))
          (when (looking-at phpcmp-etags-parse-tags-file-regexp)
            (let ((function (match-string 5)))
              (push function functions)))
          (forward-line))
         ((looking-at (rx bol (* space) "$" (+ (any alnum "_")) (* space) "="))
          (when (looking-at phpcmp-etags-parse-tags-file-regexp)
            (let ((variable (match-string 5)))
            (push variable variables)))
          (forward-line))
         (t
          (forward-line))))
      (phpcmp-make-tag
       :tag-file tag-file
       :path (concat (file-name-directory tag-file)
                     relative-file-path)
       :relative-path relative-file-path
       :classes classes
       :functions functions
       :variables variables))))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Commands ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun phpcmp-complete ()
  (interactive)
  (anything (phpcmp-make-completion-sources)
            (phpcmp-get-initial-input)))

(defun phpcmp-showdoc-at-point ()
  (interactive)
  (let* ((s (or (thing-at-point 'symbol) ""))
         (docstring (phpcmp-get-document-string s)))
    (phpcmp-showtip docstring)))

(defvar phpcmp-popup-document-buffer "*php-completion document*")
(defun phpcmp-popup-document-at-point ()
  (interactive)
  (let* ((s (or (thing-at-point 'symbol) ""))
         (docstring (phpcmp-get-document-string s)))
    (let ((b (get-buffer-create phpcmp-popup-document-buffer)))
      (with-current-buffer b
        (erase-buffer)
        (insert docstring)
        (goto-char (point-min)))
      (pop-to-buffer b))))

(defun phpcmp-reset-all-db ()
  (interactive)
  (setq phpcmp--db (make-hash-table)
        phpcmp--db-class (make-hash-table :test 'equal))
  (load (locate-library "php-completion")))

(defun phpcmp-read-tags-file (tags-file)
  (interactive "fTAGS file: ")
  (and (stringp tags-file)
       (file-readable-p tags-file)
       (phpcmp-set-etags-alist (phpcmp-etags-get-tags tags-file))))

(defun phpcmp-search ()
  (interactive)
  (let* ((initial (substring-no-properties (or (thing-at-point 'symbol) "")))
         (query (completing-read "Query: " (phpcmp-ac-get-cands) nil nil initial)))
    (and (stringp query)
         (phpcmp-search-manual query))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; auto-complete.el ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar ac-source-php-completion
  '((candidates . phpcmp-ac-build-cands)))

(defvar ac-source-php-completion-patial
  '((candidates . phpcmp-ac-build-cands-patial)))

(defun phpcmp-ac-build-cands ()
  (all-completions ac-target (phpcmp-ac-get-cands)))

(defun phpcmp-ac-build-cands-patial ()
  (let ((los (phpcmp-ac-get-cands)))
    (append (all-completions ac-target los)
            (phpcmp-ac-build-cands1 los))))

(defun phpcmp-ac-build-cands1 (los)
  (let ((match (lambda (s)
                 (and (stringp s)
                      (string-match ac-target s)
                      (not (string= ac-target s))))))
    (remove-if-not match los)))

(defun phpcmp-ac-get-cands ()
  (loop for (name get-cands-fn) in (phpcmp-completions-table)
        append (if (functionp get-cands-fn)
                   (funcall get-cands-fn)
                 get-cands-fn)))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DATA ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; (let ((s (shell-command-to-string "perl scrape-funcs.pl"))
;;       (insert (lambda (s) (insert (format "%S" s) "\n"))))
;;   (mapcar insert (split-string s "\n")))
(phpcmp-db-update
 'functions
 '(
   "__halt_compiler"
   "abs"
   "acos"
   "acosh"
   "addcslashes"
   "addslashes"
   "aggregate"
   "aggregate_info"
   "aggregate_methods"
   "aggregate_methods_by_list"
   "aggregate_methods_by_regexp"
   "aggregate_properties"
   "aggregate_properties_by_list"
   "aggregate_properties_by_regexp"
   "aggregation_info"
   "apache_child_terminate"
   "apache_get_modules"
   "apache_get_version"
   "apache_getenv"
   "apache_lookup_uri"
   "apache_note"
   "apache_request_headers"
   "apache_reset_timeout"
   "apache_response_headers"
   "apache_setenv"
   "apc_add"
   "apc_cache_info"
   "apc_clear_cache"
   "apc_compile_file"
   "apc_define_constants"
   "apc_delete"
   "apc_fetch"
   "apc_load_constants"
   "apc_sma_info"
   "apc_store"
   "apd_breakpoint"
   "apd_callstack"
   "apd_clunk"
   "apd_continue"
   "apd_croak"
   "apd_dump_function_table"
   "apd_dump_persistent_resources"
   "apd_dump_regular_resources"
   "apd_echo"
   "apd_get_active_symbols"
   "apd_set_pprof_trace"
   "apd_set_session"
   "apd_set_session_trace"
   "apd_set_socket_session_trace"
   "array"
   "array_change_key_case"
   "array_chunk"
   "array_combine"
   "array_count_values"
   "array_diff"
   "array_diff_assoc"
   "array_diff_key"
   "array_diff_uassoc"
   "array_diff_ukey"
   "array_fill"
   "array_fill_keys"
   "array_filter"
   "array_flip"
   "array_intersect"
   "array_intersect_assoc"
   "array_intersect_key"
   "array_intersect_uassoc"
   "array_intersect_ukey"
   "array_key_exists"
   "array_keys"
   "array_map"
   "array_merge"
   "array_merge_recursive"
   "array_multisort"
   "array_pad"
   "array_pop"
   "array_product"
   "array_push"
   "array_rand"
   "array_reduce"
   "array_reverse"
   "array_search"
   "array_shift"
   "array_slice"
   "array_splice"
   "array_sum"
   "array_udiff"
   "array_udiff_assoc"
   "array_udiff_uassoc"
   "array_uintersect"
   "array_uintersect_assoc"
   "array_uintersect_uassoc"
   "array_unique"
   "array_unshift"
   "array_values"
   "array_walk"
   "array_walk_recursive"
   "current"
   "key"
   "next"
   "rewind"
   "seek"
   "valid"
   "__construct"
   "append"
   "count"
   "getIterator"
   "offsetExists"
   "offsetGet"
   "offsetSet"
   "offsetUnset"
   "arsort"
   "ascii2ebcdic"
   "asin"
   "asinh"
   "asort"
   "assert"
   "assert_options"
   "atan"
   "atan2"
   "atanh"
   "base64_decode"
   "base64_encode"
   "base_convert"
   "basename"
   "bbcode_add_element"
   "bbcode_create"
   "bbcode_destroy"
   "bbcode_parse"
   "bcadd"
   "bccomp"
   "bcdiv"
   "bcmod"
   "bcmul"
   "bcompiler_load"
   "bcompiler_load_exe"
   "bcompiler_parse_class"
   "bcompiler_read"
   "bcompiler_write_class"
   "bcompiler_write_constant"
   "bcompiler_write_exe_footer"
   "bcompiler_write_file"
   "bcompiler_write_footer"
   "bcompiler_write_function"
   "bcompiler_write_functions_from_file"
   "bcompiler_write_header"
   "bcompiler_write_included_filename"
   "bcpow"
   "bcpowmod"
   "bcscale"
   "bcsqrt"
   "bcsub"
   "bin2hex"
   "bind_textdomain_codeset"
   "bindec"
   "bindtextdomain"
   "bzclose"
   "bzcompress"
   "bzdecompress"
   "bzerrno"
   "bzerror"
   "bzerrstr"
   "bzflush"
   "bzopen"
   "bzread"
   "bzwrite"
   "__toString"
   "hasNext"
   "cal_days_in_month"
   "cal_from_jd"
   "cal_info"
   "cal_to_jd"
   "call_user_func"
   "call_user_func_array"
   "call_user_method"
   "call_user_method_array"
   "ceil"
   "chdir"
   "checkdate"
   "checkdnsrr"
   "chgrp"
   "chmod"
   "chop"
   "chown"
   "chr"
   "chroot"
   "chunk_split"
   "class_exists"
   "class_implements"
   "class_parents"
   "classkit_import"
   "classkit_method_add"
   "classkit_method_copy"
   "classkit_method_redefine"
   "classkit_method_remove"
   "classkit_method_rename"
   "clearstatcache"
   "closedir"
   "closelog"
   "com"
   "com_addref"
   "com_create_guid"
   "com_event_sink"
   "com_get"
   "com_get_active_object"
   "com_invoke"
   "com_isenum"
   "com_load"
   "com_load_typelib"
   "com_message_pump"
   "com_print_typeinfo"
   "com_propget"
   "com_propput"
   "com_propset"
   "com_release"
   "com_set"
   "compact"
   "connection_aborted"
   "connection_status"
   "connection_timeout"
   "constant"
   "convert_cyr_string"
   "convert_uudecode"
   "convert_uuencode"
   "copy"
   "cos"
   "cosh"
   "count_chars"
   "crack_check"
   "crack_closedict"
   "crack_getlastmessage"
   "crack_opendict"
   "crc32"
   "create_function"
   "crypt"
   "ctype_alnum"
   "ctype_alpha"
   "ctype_cntrl"
   "ctype_digit"
   "ctype_graph"
   "ctype_lower"
   "ctype_print"
   "ctype_punct"
   "ctype_space"
   "ctype_upper"
   "ctype_xdigit"
   "curl_close"
   "curl_copy_handle"
   "curl_errno"
   "curl_error"
   "curl_exec"
   "curl_getinfo"
   "curl_init"
   "curl_multi_add_handle"
   "curl_multi_close"
   "curl_multi_exec"
   "curl_multi_getcontent"
   "curl_multi_info_read"
   "curl_multi_init"
   "curl_multi_remove_handle"
   "curl_multi_select"
   "curl_setopt"
   "curl_setopt_array"
   "curl_version"
   "cyrus_authenticate"
   "cyrus_bind"
   "cyrus_close"
   "cyrus_connect"
   "cyrus_query"
   "cyrus_unbind"
   "date"
   "date_create"
   "date_date_set"
   "date_default_timezone_get"
   "date_default_timezone_set"
   "date_format"
   "date_isodate_set"
   "date_modify"
   "date_offset_get"
   "date_parse"
   "date_sun_info"
   "date_sunrise"
   "date_sunset"
   "date_time_set"
   "date_timezone_get"
   "date_timezone_set"
   "db2_autocommit"
   "db2_bind_param"
   "db2_client_info"
   "db2_close"
   "db2_column_privileges"
   "db2_columns"
   "db2_commit"
   "db2_conn_error"
   "db2_conn_errormsg"
   "db2_connect"
   "db2_cursor_type"
   "db2_escape_string"
   "db2_exec"
   "db2_execute"
   "db2_fetch_array"
   "db2_fetch_assoc"
   "db2_fetch_both"
   "db2_fetch_object"
   "db2_fetch_row"
   "db2_field_display_size"
   "db2_field_name"
   "db2_field_num"
   "db2_field_precision"
   "db2_field_scale"
   "db2_field_type"
   "db2_field_width"
   "db2_foreign_keys"
   "db2_free_result"
   "db2_free_stmt"
   "db2_get_option"
   "db2_lob_read"
   "db2_next_result"
   "db2_num_fields"
   "db2_num_rows"
   "db2_pconnect"
   "db2_prepare"
   "db2_primary_keys"
   "db2_procedure_columns"
   "db2_procedures"
   "db2_result"
   "db2_rollback"
   "db2_server_info"
   "db2_set_option"
   "db2_special_columns"
   "db2_statistics"
   "db2_stmt_error"
   "db2_stmt_errormsg"
   "db2_table_privileges"
   "db2_tables"
   "dba_close"
   "dba_delete"
   "dba_exists"
   "dba_fetch"
   "dba_firstkey"
   "dba_handlers"
   "dba_insert"
   "dba_key_split"
   "dba_list"
   "dba_nextkey"
   "dba_open"
   "dba_optimize"
   "dba_popen"
   "dba_replace"
   "dba_sync"
   "dbase_add_record"
   "dbase_close"
   "dbase_create"
   "dbase_delete_record"
   "dbase_get_header_info"
   "dbase_get_record"
   "dbase_get_record_with_names"
   "dbase_numfields"
   "dbase_numrecords"
   "dbase_open"
   "dbase_pack"
   "dbase_replace_record"
   "dbplus_add"
   "dbplus_aql"
   "dbplus_chdir"
   "dbplus_close"
   "dbplus_curr"
   "dbplus_errcode"
   "dbplus_errno"
   "dbplus_find"
   "dbplus_first"
   "dbplus_flush"
   "dbplus_freealllocks"
   "dbplus_freelock"
   "dbplus_freerlocks"
   "dbplus_getlock"
   "dbplus_getunique"
   "dbplus_info"
   "dbplus_last"
   "dbplus_lockrel"
   "dbplus_next"
   "dbplus_open"
   "dbplus_prev"
   "dbplus_rchperm"
   "dbplus_rcreate"
   "dbplus_rcrtexact"
   "dbplus_rcrtlike"
   "dbplus_resolve"
   "dbplus_restorepos"
   "dbplus_rkeys"
   "dbplus_ropen"
   "dbplus_rquery"
   "dbplus_rrename"
   "dbplus_rsecindex"
   "dbplus_runlink"
   "dbplus_rzap"
   "dbplus_savepos"
   "dbplus_setindex"
   "dbplus_setindexbynumber"
   "dbplus_sql"
   "dbplus_tcl"
   "dbplus_tremove"
   "dbplus_undo"
   "dbplus_undoprepare"
   "dbplus_unlockrel"
   "dbplus_unselect"
   "dbplus_update"
   "dbplus_xlockrel"
   "dbplus_xunlockrel"
   "dbx_close"
   "dbx_compare"
   "dbx_connect"
   "dbx_error"
   "dbx_escape_string"
   "dbx_fetch_row"
   "dbx_query"
   "dbx_sort"
   "dcgettext"
   "dcngettext"
   "deaggregate"
   "debug_backtrace"
   "debug_print_backtrace"
   "debug_zval_dump"
   "decbin"
   "dechex"
   "decoct"
   "define"
   "define_syslog_variables"
   "defined"
   "deg2rad"
   "delete"
   "dgettext"
   "die"
   "dio_close"
   "dio_fcntl"
   "dio_open"
   "dio_read"
   "dio_seek"
   "dio_stat"
   "dio_tcsetattr"
   "dio_truncate"
   "dio_write"
   "dir"
   "getATime"
   "getCTime"
   "getFilename"
   "getGroup"
   "getInode"
   "getMTime"
   "getOwner"
   "getPath"
   "getPathname"
   "getPerms"
   "getSize"
   "getType"
   "isDir"
   "isDot"
   "isExecutable"
   "isFile"
   "isLink"
   "isReadable"
   "isWritable"
   "dirname"
   "disk_free_space"
   "disk_total_space"
   "diskfreespace"
   "dl"
   "dngettext"
   "dns_check_record"
   "dns_get_mx"
   "dns_get_record"
   "dom_import_simplexml"
   "isId"
   "name"
   "set_value"
   "specified"
   "value"
   "appendData"
   "deleteData"
   "insertData"
   "replaceData"
   "substringData"
   "add_root"
   "create_attribute"
   "create_cdata_section"
   "create_comment"
   "create_element"
   "create_element_ns"
   "create_entity_reference"
   "create_processing_instruction"
   "create_text_node"
   "createAttribute"
   "createAttributeNS"
   "createCDATASection"
   "createComment"
   "createDocumentFragment"
   "createElement"
   "createElementNS"
   "createEntityReference"
   "createProcessingInstruction"
   "createTextNode"
   "doctype"
   "document_element"
   "dump_file"
   "dump_mem"
   "get_element_by_id"
   "get_elements_by_tagname"
   "getElementById"
   "getElementsByTagName"
   "getElementsByTagNameNS"
   "html_dump_mem"
   "importNode"
   "load"
   "loadHTML"
   "loadHTMLFile"
   "loadXML"
   "normalizeDocument"
   "registerNodeClass"
   "relaxNGValidate"
   "relaxNGValidateSource"
   "save"
   "saveHTML"
   "saveHTMLFile"
   "saveXML"
   "schemaValidate"
   "schemaValidateSource"
   "validate"
   "xinclude"
   "appendXML"
   "entities"
   "internal_subset"
   "notations"
   "public_id"
   "system_id"
   "get_attribute"
   "get_attribute_node"
   "getAttribute"
   "getAttributeNode"
   "getAttributeNodeNS"
   "getAttributeNS"
   "has_attribute"
   "hasAttribute"
   "hasAttributeNS"
   "remove_attribute"
   "removeAttribute"
   "removeAttributeNode"
   "removeAttributeNS"
   "set_attribute"
   "set_attribute_node"
   "setAttribute"
   "setAttributeNode"
   "setAttributeNodeNS"
   "setAttributeNS"
   "setIdAttribute"
   "setIdAttributeNode"
   "setIdAttributeNS"
   "tagname"
   "createDocument"
   "createDocumentType"
   "hasFeature"
   "getNamedItem"
   "getNamedItemNS"
   "item"
   "add_namespace"
   "append_child"
   "append_sibling"
   "appendChild"
   "attributes"
   "child_nodes"
   "clone_node"
   "cloneNode"
   "dump_node"
   "first_child"
   "get_content"
   "has_attributes"
   "has_child_nodes"
   "hasAttributes"
   "hasChildNodes"
   "insert_before"
   "insertBefore"
   "is_blank_node"
   "isDefaultNamespace"
   "isSameNode"
   "isSupported"
   "last_child"
   "lookupNamespaceURI"
   "lookupPrefix"
   "next_sibling"
   "node_name"
   "node_type"
   "node_value"
   "normalize"
   "owner_document"
   "parent_node"
   "prefix"
   "previous_sibling"
   "remove_child"
   "removeChild"
   "replace_child"
   "replace_node"
   "replaceChild"
   "set_content"
   "set_name"
   "set_namespace"
   "unlink_node"
   "data"
   "target"
   "isWhitespaceInElementContent"
   "splitText"
   "domxml_new_doc"
   "domxml_open_file"
   "domxml_open_mem"
   "domxml_version"
   "domxml_xmltree"
   "domxml_xslt_stylesheet"
   "domxml_xslt_stylesheet_doc"
   "domxml_xslt_stylesheet_file"
   "domxml_xslt_version"
   "evaluate"
   "query"
   "registerNamespace"
   "process"
   "result_dump_file"
   "result_dump_mem"
   "dotnet"
   "dotnet_load"
   "doubleval"
   "each"
   "easter_date"
   "easter_days"
   "ebcdic2ascii"
   "echo"
   "empty"
   "enchant_broker_describe"
   "enchant_broker_dict_exists"
   "enchant_broker_free"
   "enchant_broker_free_dict"
   "enchant_broker_get_error"
   "enchant_broker_init"
   "enchant_broker_list_dicts"
   "enchant_broker_request_dict"
   "enchant_broker_request_pwl_dict"
   "enchant_broker_set_ordering"
   "enchant_dict_add_to_personal"
   "enchant_dict_add_to_session"
   "enchant_dict_check"
   "enchant_dict_describe"
   "enchant_dict_get_error"
   "enchant_dict_is_in_session"
   "enchant_dict_quick_check"
   "enchant_dict_store_replacement"
   "enchant_dict_suggest"
   "end"
   "ereg"
   "ereg_replace"
   "eregi"
   "eregi_replace"
   "error_get_last"
   "error_log"
   "error_reporting"
   "escapeshellarg"
   "escapeshellcmd"
   "eval"
   "exec"
   "exif_imagetype"
   "exif_read_data"
   "exif_tagname"
   "exif_thumbnail"
   "exit"
   "exp"
   "expect_expectl"
   "expect_popen"
   "explode"
   "expm1"
   "extension_loaded"
   "extract"
   "ezmlm_hash"
   "fam_cancel_monitor"
   "fam_close"
   "fam_monitor_collection"
   "fam_monitor_directory"
   "fam_monitor_file"
   "fam_next_event"
   "fam_open"
   "fam_pending"
   "fam_resume_monitor"
   "fam_suspend_monitor"
   "fbsql_affected_rows"
   "fbsql_autocommit"
   "fbsql_blob_size"
   "fbsql_change_user"
   "fbsql_clob_size"
   "fbsql_close"
   "fbsql_commit"
   "fbsql_connect"
   "fbsql_create_blob"
   "fbsql_create_clob"
   "fbsql_create_db"
   "fbsql_data_seek"
   "fbsql_database"
   "fbsql_database_password"
   "fbsql_db_query"
   "fbsql_db_status"
   "fbsql_drop_db"
   "fbsql_errno"
   "fbsql_error"
   "fbsql_fetch_array"
   "fbsql_fetch_assoc"
   "fbsql_fetch_field"
   "fbsql_fetch_lengths"
   "fbsql_fetch_object"
   "fbsql_fetch_row"
   "fbsql_field_flags"
   "fbsql_field_len"
   "fbsql_field_name"
   "fbsql_field_seek"
   "fbsql_field_table"
   "fbsql_field_type"
   "fbsql_free_result"
   "fbsql_get_autostart_info"
   "fbsql_hostname"
   "fbsql_insert_id"
   "fbsql_list_dbs"
   "fbsql_list_fields"
   "fbsql_list_tables"
   "fbsql_next_result"
   "fbsql_num_fields"
   "fbsql_num_rows"
   "fbsql_password"
   "fbsql_pconnect"
   "fbsql_query"
   "fbsql_read_blob"
   "fbsql_read_clob"
   "fbsql_result"
   "fbsql_rollback"
   "fbsql_rows_fetched"
   "fbsql_select_db"
   "fbsql_set_characterset"
   "fbsql_set_lob_mode"
   "fbsql_set_password"
   "fbsql_set_transaction"
   "fbsql_start_db"
   "fbsql_stop_db"
   "fbsql_table_name"
   "fbsql_tablename"
   "fbsql_username"
   "fbsql_warnings"
   "fclose"
   "fdf_add_doc_javascript"
   "fdf_add_template"
   "fdf_close"
   "fdf_create"
   "fdf_enum_values"
   "fdf_errno"
   "fdf_error"
   "fdf_get_ap"
   "fdf_get_attachment"
   "fdf_get_encoding"
   "fdf_get_file"
   "fdf_get_flags"
   "fdf_get_opt"
   "fdf_get_status"
   "fdf_get_value"
   "fdf_get_version"
   "fdf_header"
   "fdf_next_field_name"
   "fdf_open"
   "fdf_open_string"
   "fdf_remove_item"
   "fdf_save"
   "fdf_save_string"
   "fdf_set_ap"
   "fdf_set_encoding"
   "fdf_set_file"
   "fdf_set_flags"
   "fdf_set_javascript_action"
   "fdf_set_on_import_javascript"
   "fdf_set_opt"
   "fdf_set_status"
   "fdf_set_submit_form_action"
   "fdf_set_target_frame"
   "fdf_set_value"
   "fdf_set_version"
   "feof"
   "fflush"
   "fgetc"
   "fgetcsv"
   "fgets"
   "fgetss"
   "file"
   "file_exists"
   "file_get_contents"
   "file_put_contents"
   "fileatime"
   "filectime"
   "filegroup"
   "fileinode"
   "filemtime"
   "fileowner"
   "fileperms"
   "filepro"
   "filepro_fieldcount"
   "filepro_fieldname"
   "filepro_fieldtype"
   "filepro_fieldwidth"
   "filepro_retrieve"
   "filepro_rowcount"
   "filesize"
   "filetype"
   "filter_has_var"
   "filter_id"
   "filter_input"
   "filter_input_array"
   "filter_list"
   "filter_var"
   "filter_var_array"
   "getInnerIterator"
   "finfo_buffer"
   "finfo_close"
   "finfo_file"
   "finfo_open"
   "finfo_set_flags"
   "floatval"
   "flock"
   "floor"
   "flush"
   "fmod"
   "fnmatch"
   "fopen"
   "fpassthru"
   "fprintf"
   "fputcsv"
   "fputs"
   "fread"
   "frenchtojd"
   "fribidi_log2vis"
   "fscanf"
   "fseek"
   "fsockopen"
   "fstat"
   "ftell"
   "ftok"
   "ftp_alloc"
   "ftp_cdup"
   "ftp_chdir"
   "ftp_chmod"
   "ftp_close"
   "ftp_connect"
   "ftp_delete"
   "ftp_exec"
   "ftp_fget"
   "ftp_fput"
   "ftp_get"
   "ftp_get_option"
   "ftp_login"
   "ftp_mdtm"
   "ftp_mkdir"
   "ftp_nb_continue"
   "ftp_nb_fget"
   "ftp_nb_fput"
   "ftp_nb_get"
   "ftp_nb_put"
   "ftp_nlist"
   "ftp_pasv"
   "ftp_put"
   "ftp_pwd"
   "ftp_quit"
   "ftp_raw"
   "ftp_rawlist"
   "ftp_rename"
   "ftp_rmdir"
   "ftp_set_option"
   "ftp_site"
   "ftp_size"
   "ftp_ssl_connect"
   "ftp_systype"
   "ftruncate"
   "func_get_arg"
   "func_get_args"
   "func_num_args"
   "function_exists"
   "fwrite"
   "gd_info"
   "geoip_country_code3_by_name"
   "geoip_country_code_by_name"
   "geoip_country_name_by_name"
   "geoip_database_info"
   "geoip_db_avail"
   "geoip_db_filename"
   "geoip_db_get_all_info"
   "geoip_id_by_name"
   "geoip_org_by_name"
   "geoip_record_by_name"
   "geoip_region_by_name"
   "get_browser"
   "get_cfg_var"
   "get_class"
   "get_class_methods"
   "get_class_vars"
   "get_current_user"
   "get_declared_classes"
   "get_declared_interfaces"
   "get_defined_constants"
   "get_defined_functions"
   "get_defined_vars"
   "get_extension_funcs"
   "get_headers"
   "get_html_translation_table"
   "get_include_path"
   "get_included_files"
   "get_loaded_extensions"
   "get_magic_quotes_gpc"
   "get_magic_quotes_runtime"
   "get_meta_tags"
   "get_object_vars"
   "get_parent_class"
   "get_required_files"
   "get_resource_type"
   "getallheaders"
   "getcwd"
   "getdate"
   "getenv"
   "gethostbyaddr"
   "gethostbyname"
   "gethostbynamel"
   "getimagesize"
   "getlastmod"
   "getmxrr"
   "getmygid"
   "getmyinode"
   "getmypid"
   "getmyuid"
   "getopt"
   "getprotobyname"
   "getprotobynumber"
   "getrandmax"
   "getrusage"
   "getservbyname"
   "getservbyport"
   "gettext"
   "gettimeofday"
   "gettype"
   "glob"
   "gmdate"
   "gmmktime"
   "gmp_abs"
   "gmp_add"
   "gmp_and"
   "gmp_clrbit"
   "gmp_cmp"
   "gmp_com"
   "gmp_div"
   "gmp_div_q"
   "gmp_div_qr"
   "gmp_div_r"
   "gmp_divexact"
   "gmp_fact"
   "gmp_gcd"
   "gmp_gcdext"
   "gmp_hamdist"
   "gmp_init"
   "gmp_intval"
   "gmp_invert"
   "gmp_jacobi"
   "gmp_legendre"
   "gmp_mod"
   "gmp_mul"
   "gmp_neg"
   "gmp_nextprime"
   "gmp_or"
   "gmp_perfect_square"
   "gmp_popcount"
   "gmp_pow"
   "gmp_powm"
   "gmp_prob_prime"
   "gmp_random"
   "gmp_scan0"
   "gmp_scan1"
   "gmp_setbit"
   "gmp_sign"
   "gmp_sqrt"
   "gmp_sqrtrem"
   "gmp_strval"
   "gmp_sub"
   "gmp_testbit"
   "gmp_xor"
   "gmstrftime"
   "gnupg_adddecryptkey"
   "gnupg_addencryptkey"
   "gnupg_addsignkey"
   "gnupg_cleardecryptkeys"
   "gnupg_clearencryptkeys"
   "gnupg_clearsignkeys"
   "gnupg_decrypt"
   "gnupg_decryptverify"
   "gnupg_encrypt"
   "gnupg_encryptsign"
   "gnupg_export"
   "gnupg_geterror"
   "gnupg_getprotocol"
   "gnupg_import"
   "gnupg_keyinfo"
   "gnupg_setarmor"
   "gnupg_seterrormode"
   "gnupg_setsignmode"
   "gnupg_sign"
   "gnupg_verify"
   "gopher_parsedir"
   "gregoriantojd"
   "gzclose"
   "gzcompress"
   "gzdecode"
   "gzdeflate"
   "gzencode"
   "gzeof"
   "gzfile"
   "gzgetc"
   "gzgets"
   "gzgetss"
   "gzinflate"
   "gzopen"
   "gzpassthru"
   "gzputs"
   "gzread"
   "gzrewind"
   "gzseek"
   "gztell"
   "gzuncompress"
   "gzwrite"
   "setBorderStyle"
   "setHighlightMode"
   "setIcon"
   "setOpened"
   "setFit"
   "setFitB"
   "setFitBH"
   "setFitBV"
   "setFitH"
   "setFitR"
   "setFitV"
   "setXYZ"
   "addPage"
   "addPageLabel"
   "createOutline"
   "getCurrentEncoder"
   "getCurrentPage"
   "getEncoder"
   "getFont"
   "getInfoAttr"
   "getPageLayout"
   "getPageMode"
   "getStreamSize"
   "insertPage"
   "loadJPEG"
   "loadPNG"
   "loadRaw"
   "loadTTC"
   "loadTTF"
   "loadType1"
   "output"
   "readFromStream"
   "resetError"
   "resetStream"
   "saveToStream"
   "setCompressionMode"
   "setCurrentEncoder"
   "setEncryptionMode"
   "setInfoAttr"
   "setInfoDateAttr"
   "setOpenAction"
   "setPageLayout"
   "setPageMode"
   "setPagesConfiguration"
   "setPassword"
   "setPermission"
   "useCNSEncodings"
   "useCNSFonts"
   "useCNTEncodings"
   "useCNTFonts"
   "useJPEncodings"
   "useJPFonts"
   "useKREncodings"
   "useKRFonts"
   "getByteType"
   "getUnicode"
   "getWritingMode"
   "getAscent"
   "getCapHeight"
   "getDescent"
   "getEncodingName"
   "getFontName"
   "getTextWidth"
   "getUnicodeWidth"
   "getXHeight"
   "measureText"
   "getBitsPerComponent"
   "getColorSpace"
   "getHeight"
   "getWidth"
   "setColorMask"
   "setMaskImage"
   "setDestination"
   "arc"
   "beginText"
   "circle"
   "closePath"
   "concat"
   "createDestination"
   "createLinkAnnotation"
   "createTextAnnotation"
   "createURLAnnotation"
   "curveTo"
   "curveTo2"
   "curveTo3"
   "drawImage"
   "ellipse"
   "endPath"
   "endText"
   "eofill"
   "eoFillStroke"
   "fill"
   "fillStroke"
   "getCharSpace"
   "getCMYKFill"
   "getCMYKStroke"
   "getCurrentFont"
   "getCurrentFontSize"
   "getCurrentPos"
   "getCurrentTextPos"
   "getDash"
   "getFillingColorSpace"
   "getFlatness"
   "getGMode"
   "getGrayFill"
   "getGrayStroke"
   "getHorizontalScaling"
   "getLineCap"
   "getLineJoin"
   "getLineWidth"
   "getMiterLimit"
   "getRGBFill"
   "getRGBStroke"
   "getStrokingColorSpace"
   "getTextLeading"
   "getTextMatrix"
   "getTextRenderingMode"
   "getTextRise"
   "getTransMatrix"
   "getWordSpace"
   "lineTo"
   "moveTextPos"
   "moveTo"
   "moveToNextLine"
   "rectangle"
   "setCharSpace"
   "setCMYKFill"
   "setCMYKStroke"
   "setDash"
   "setFlatness"
   "setFontAndSize"
   "setGrayFill"
   "setGrayStroke"
   "setHeight"
   "setHorizontalScaling"
   "setLineCap"
   "setLineJoin"
   "setLineWidth"
   "setMiterLimit"
   "setRGBFill"
   "setRGBStroke"
   "setRotate"
   "setSize"
   "setSlideShow"
   "setTextLeading"
   "setTextMatrix"
   "setTextRenderingMode"
   "setTextRise"
   "setWidth"
   "setWordSpace"
   "showText"
   "showTextNextLine"
   "stroke"
   "textOut"
   "textRect"
   "hash"
   "hash_algos"
   "hash_file"
   "hash_final"
   "hash_hmac"
   "hash_hmac_file"
   "hash_init"
   "hash_update"
   "hash_update_file"
   "hash_update_stream"
   "header"
   "headers_list"
   "headers_sent"
   "hebrev"
   "hebrevc"
   "hexdec"
   "highlight_file"
   "highlight_string"
   "html_entity_decode"
   "htmlentities"
   "htmlspecialchars"
   "htmlspecialchars_decode"
   "http_build_cookie"
   "http_build_query"
   "http_build_str"
   "http_build_url"
   "http_cache_etag"
   "http_cache_last_modified"
   "http_chunked_decode"
   "http_date"
   "http_deflate"
   "http_get"
   "http_get_request_body"
   "http_get_request_body_stream"
   "http_get_request_headers"
   "http_head"
   "http_inflate"
   "http_match_etag"
   "http_match_modified"
   "http_match_request_header"
   "http_negotiate_charset"
   "http_negotiate_content_type"
   "http_negotiate_language"
   "http_parse_cookie"
   "http_parse_headers"
   "http_parse_message"
   "http_parse_params"
   "http_persistent_handles_clean"
   "http_persistent_handles_count"
   "http_persistent_handles_ident"
   "http_post_data"
   "http_post_fields"
   "http_put_data"
   "http_put_file"
   "http_put_stream"
   "http_redirect"
   "http_request"
   "http_request_body_encode"
   "http_request_method_exists"
   "http_request_method_name"
   "http_request_method_register"
   "http_request_method_unregister"
   "http_send_content_disposition"
   "http_send_content_type"
   "http_send_data"
   "http_send_file"
   "http_send_last_modified"
   "http_send_status"
   "http_send_stream"
   "http_support"
   "http_throttle"
   "factory"
   "finish"
   "update"
   "addHeaders"
   "detach"
   "fromEnv"
   "fromString"
   "getBody"
   "getHeader"
   "getHeaders"
   "getHttpVersion"
   "getParentMessage"
   "getRequestMethod"
   "getRequestUrl"
   "getResponseCode"
   "getResponseStatus"
   "guessContentType"
   "prepend"
   "reverse"
   "send"
   "setBody"
   "setHeaders"
   "setHttpVersion"
   "setRequestMethod"
   "setRequestUrl"
   "setResponseCode"
   "setResponseStatus"
   "setType"
   "toMessageTypeObject"
   "toString"
   "get"
   "mod"
   "set"
   "singleton"
   "toArray"
   "xlate"
   "addCookies"
   "addPostFields"
   "addPostFile"
   "addPutData"
   "addQueryData"
   "addRawPostData"
   "addSslOptions"
   "clearHistory"
   "enableCookies"
   "getContentType"
   "getCookies"
   "getHistory"
   "getMethod"
   "getOptions"
   "getPostFields"
   "getPostFiles"
   "getPutData"
   "getPutFile"
   "getQueryData"
   "getRawPostData"
   "getRawRequestMessage"
   "getRawResponseMessage"
   "getRequestMessage"
   "getResponseBody"
   "getResponseCookies"
   "getResponseData"
   "getResponseHeader"
   "getResponseInfo"
   "getResponseMessage"
   "getSslOptions"
   "getUrl"
   "resetCookies"
   "setContentType"
   "setCookies"
   "setMethod"
   "setOptions"
   "setPostFields"
   "setPostFiles"
   "setPutData"
   "setPutFile"
   "setQueryData"
   "setRawPostData"
   "setSslOptions"
   "setUrl"
   "__destruct"
   "attach"
   "getAttachedRequests"
   "getFinishedRequests"
   "reset"
   "socketPerform"
   "socketSelect"
   "capture"
   "getBufferSize"
   "getCache"
   "getCacheControl"
   "getContentDisposition"
   "getData"
   "getETag"
   "getFile"
   "getGzip"
   "getLastModified"
   "getRequestBody"
   "getRequestBodyStream"
   "getRequestHeaders"
   "getStream"
   "getThrottleDelay"
   "redirect"
   "setBufferSize"
   "setCache"
   "setCacheControl"
   "setContentDisposition"
   "setData"
   "setETag"
   "setFile"
   "setGzip"
   "setHeader"
   "setLastModified"
   "setStream"
   "setThrottleDelay"
   "status"
   "checkin"
   "checkout"
   "children"
   "content"
   "dbstat"
   "dcstat"
   "dstanchors"
   "dstofsrcanchor"
   "find"
   "ftstat"
   "hwstat"
   "identify"
   "info"
   "insert"
   "insertanchor"
   "insertcollection"
   "insertdocument"
   "link"
   "lock"
   "move"
   "object"
   "objectbyanchor"
   "parents"
   "remove"
   "replace"
   "setcommittedversion"
   "srcanchors"
   "srcsofdst"
   "unlock"
   "user"
   "userlist"
   "hw_api_attribute"
   "langdepvalue"
   "values"
   "hw_api_content"
   "mimetype"
   "read"
   "reason"
   "hw_api_object"
   "assign"
   "attreditable"
   "title"
   "description"
   "type"
   "hw_array2objrec"
   "hw_changeobject"
   "hw_children"
   "hw_childrenobj"
   "hw_close"
   "hw_connect"
   "hw_connection_info"
   "hw_cp"
   "hw_deleteobject"
   "hw_docbyanchor"
   "hw_docbyanchorobj"
   "hw_document_attributes"
   "hw_document_bodytag"
   "hw_document_content"
   "hw_document_setcontent"
   "hw_document_size"
   "hw_dummy"
   "hw_edittext"
   "hw_error"
   "hw_errormsg"
   "hw_free_document"
   "hw_getanchors"
   "hw_getanchorsobj"
   "hw_getandlock"
   "hw_getchildcoll"
   "hw_getchildcollobj"
   "hw_getchilddoccoll"
   "hw_getchilddoccollobj"
   "hw_getobject"
   "hw_getobjectbyquery"
   "hw_getobjectbyquerycoll"
   "hw_getobjectbyquerycollobj"
   "hw_getobjectbyqueryobj"
   "hw_getparents"
   "hw_getparentsobj"
   "hw_getrellink"
   "hw_getremote"
   "hw_getremotechildren"
   "hw_getsrcbydestobj"
   "hw_gettext"
   "hw_getusername"
   "hw_identify"
   "hw_incollections"
   "hw_info"
   "hw_inscoll"
   "hw_insdoc"
   "hw_insertanchors"
   "hw_insertdocument"
   "hw_insertobject"
   "hw_mapid"
   "hw_modifyobject"
   "hw_mv"
   "hw_new_document"
   "hw_objrec2array"
   "hw_output_document"
   "hw_pconnect"
   "hw_pipedocument"
   "hw_root"
   "hw_setlinkroot"
   "hw_stat"
   "hw_unlock"
   "hw_who"
   "hwapi_hgcsp"
   "hypot"
   "ibase_add_user"
   "ibase_affected_rows"
   "ibase_backup"
   "ibase_blob_add"
   "ibase_blob_cancel"
   "ibase_blob_close"
   "ibase_blob_create"
   "ibase_blob_echo"
   "ibase_blob_get"
   "ibase_blob_import"
   "ibase_blob_info"
   "ibase_blob_open"
   "ibase_close"
   "ibase_commit"
   "ibase_commit_ret"
   "ibase_connect"
   "ibase_db_info"
   "ibase_delete_user"
   "ibase_drop_db"
   "ibase_errcode"
   "ibase_errmsg"
   "ibase_execute"
   "ibase_fetch_assoc"
   "ibase_fetch_object"
   "ibase_fetch_row"
   "ibase_field_info"
   "ibase_free_event_handler"
   "ibase_free_query"
   "ibase_free_result"
   "ibase_gen_id"
   "ibase_maintain_db"
   "ibase_modify_user"
   "ibase_name_result"
   "ibase_num_fields"
   "ibase_num_params"
   "ibase_param_info"
   "ibase_pconnect"
   "ibase_prepare"
   "ibase_query"
   "ibase_restore"
   "ibase_rollback"
   "ibase_rollback_ret"
   "ibase_server_info"
   "ibase_service_attach"
   "ibase_service_detach"
   "ibase_set_event_handler"
   "ibase_timefmt"
   "ibase_trans"
   "ibase_wait_event"
   "iconv"
   "iconv_get_encoding"
   "iconv_mime_decode"
   "iconv_mime_decode_headers"
   "iconv_mime_encode"
   "iconv_set_encoding"
   "iconv_strlen"
   "iconv_strpos"
   "iconv_strrpos"
   "iconv_substr"
   "id3_get_frame_long_name"
   "id3_get_frame_short_name"
   "id3_get_genre_id"
   "id3_get_genre_list"
   "id3_get_genre_name"
   "id3_get_tag"
   "id3_get_version"
   "id3_remove_tag"
   "id3_set_tag"
   "idate"
   "ifx_affected_rows"
   "ifx_blobinfile_mode"
   "ifx_byteasvarchar"
   "ifx_close"
   "ifx_connect"
   "ifx_copy_blob"
   "ifx_create_blob"
   "ifx_create_char"
   "ifx_do"
   "ifx_error"
   "ifx_errormsg"
   "ifx_fetch_row"
   "ifx_fieldproperties"
   "ifx_fieldtypes"
   "ifx_free_blob"
   "ifx_free_char"
   "ifx_free_result"
   "ifx_get_blob"
   "ifx_get_char"
   "ifx_getsqlca"
   "ifx_htmltbl_result"
   "ifx_nullformat"
   "ifx_num_fields"
   "ifx_num_rows"
   "ifx_pconnect"
   "ifx_prepare"
   "ifx_query"
   "ifx_textasvarchar"
   "ifx_update_blob"
   "ifx_update_char"
   "ifxus_close_slob"
   "ifxus_create_slob"
   "ifxus_free_slob"
   "ifxus_open_slob"
   "ifxus_read_slob"
   "ifxus_seek_slob"
   "ifxus_tell_slob"
   "ifxus_write_slob"
   "ignore_user_abort"
   "iis_add_server"
   "iis_get_dir_security"
   "iis_get_script_map"
   "iis_get_server_by_comment"
   "iis_get_server_by_path"
   "iis_get_server_rights"
   "iis_get_service_state"
   "iis_remove_server"
   "iis_set_app_settings"
   "iis_set_dir_security"
   "iis_set_script_map"
   "iis_set_server_rights"
   "iis_start_server"
   "iis_start_service"
   "iis_stop_server"
   "iis_stop_service"
   "image2wbmp"
   "image_type_to_extension"
   "image_type_to_mime_type"
   "imagealphablending"
   "imageantialias"
   "imagearc"
   "imagechar"
   "imagecharup"
   "imagecolorallocate"
   "imagecolorallocatealpha"
   "imagecolorat"
   "imagecolorclosest"
   "imagecolorclosestalpha"
   "imagecolorclosesthwb"
   "imagecolordeallocate"
   "imagecolorexact"
   "imagecolorexactalpha"
   "imagecolormatch"
   "imagecolorresolve"
   "imagecolorresolvealpha"
   "imagecolorset"
   "imagecolorsforindex"
   "imagecolorstotal"
   "imagecolortransparent"
   "imageconvolution"
   "imagecopy"
   "imagecopymerge"
   "imagecopymergegray"
   "imagecopyresampled"
   "imagecopyresized"
   "imagecreate"
   "imagecreatefromgd"
   "imagecreatefromgd2"
   "imagecreatefromgd2part"
   "imagecreatefromgif"
   "imagecreatefromjpeg"
   "imagecreatefrompng"
   "imagecreatefromstring"
   "imagecreatefromwbmp"
   "imagecreatefromxbm"
   "imagecreatefromxpm"
   "imagecreatetruecolor"
   "imagedashedline"
   "imagedestroy"
   "imageellipse"
   "imagefill"
   "imagefilledarc"
   "imagefilledellipse"
   "imagefilledpolygon"
   "imagefilledrectangle"
   "imagefilltoborder"
   "imagefilter"
   "imagefontheight"
   "imagefontwidth"
   "imageftbbox"
   "imagefttext"
   "imagegammacorrect"
   "imagegd"
   "imagegd2"
   "imagegif"
   "imagegrabscreen"
   "imagegrabwindow"
   "imageinterlace"
   "imageistruecolor"
   "imagejpeg"
   "imagelayereffect"
   "imageline"
   "imageloadfont"
   "imagepalettecopy"
   "imagepng"
   "imagepolygon"
   "imagepsbbox"
   "imagepsencodefont"
   "imagepsextendfont"
   "imagepsfreefont"
   "imagepsloadfont"
   "imagepsslantfont"
   "imagepstext"
   "imagerectangle"
   "imagerotate"
   "imagesavealpha"
   "imagesetbrush"
   "imagesetpixel"
   "imagesetstyle"
   "imagesetthickness"
   "imagesettile"
   "imagestring"
   "imagestringup"
   "imagesx"
   "imagesy"
   "imagetruecolortopalette"
   "imagettfbbox"
   "imagettftext"
   "imagetypes"
   "imagewbmp"
   "imagexbm"
   "adaptiveBlurImage"
   "adaptiveResizeImage"
   "adaptiveSharpenImage"
   "adaptiveThresholdImage"
   "addImage"
   "addNoiseImage"
   "affineTransformImage"
   "annotateImage"
   "appendImages"
   "averageImages"
   "blackThresholdImage"
   "blurImage"
   "borderImage"
   "charcoalImage"
   "chopImage"
   "clear"
   "clipImage"
   "clipPathImage"
   "clone"
   "coalesceImages"
   "colorFloodfillImage"
   "colorizeImage"
   "combineImages"
   "commentImage"
   "compareImageChannels"
   "compareImageLayers"
   "compositeImage"
   "contrastImage"
   "contrastStretchImage"
   "convolveImage"
   "cropImage"
   "cropThumbnailImage"
   "cycleColormapImage"
   "deconstructImages"
   "despeckleImage"
   "destroy"
   "displayImage"
   "displayImages"
   "edgeImage"
   "embossImage"
   "enhanceImage"
   "equalizeImage"
   "evaluateImage"
   "flattenImages"
   "flipImage"
   "flopImage"
   "frameImage"
   "fxImage"
   "gammaImage"
   "gaussianBlurImage"
   "getCompression"
   "getCompressionQuality"
   "getCopyright"
   "getFormat"
   "getHomeURL"
   "getImage"
   "getImageBackgroundColor"
   "getImageBlob"
   "getImageBluePrimary"
   "getImageBorderColor"
   "getImageChannelDepth"
   "getImageChannelDistortion"
   "getImageChannelExtrema"
   "getImageChannelMean"
   "getImageChannelStatistics"
   "getImageColormapColor"
   "getImageColors"
   "getImageColorspace"
   "getImageCompose"
   "getImageDelay"
   "getImageDepth"
   "getImageDispose"
   "getImageDistortion"
   "getImageExtrema"
   "getImageFilename"
   "getImageFormat"
   "getImageGamma"
   "getImageGeometry"
   "getImageGreenPrimary"
   "getImageHeight"
   "getImageHistogram"
   "getImageIndex"
   "getImageInterlaceScheme"
   "getImageInterpolateMethod"
   "getImageIterations"
   "getImageMatte"
   "getImageMatteColor"
   "getImagePage"
   "getImagePixelColor"
   "getImageProfile"
   "getImageProperty"
   "getImageRedPrimary"
   "getImageRegion"
   "getImageRenderingIntent"
   "getImageResolution"
   "getImageScene"
   "getImageSignature"
   "getImageSize"
   "getImageTicksPerSecond"
   "getImageTotalInkDensity"
   "getImageType"
   "getImageUnits"
   "getImageVirtualPixelMethod"
   "getImageWhitePoint"
   "getImageWidth"
   "getInterlaceScheme"
   "getNumberImages"
   "getOption"
   "getPackageName"
   "getPage"
   "getPixelIterator"
   "getPixelRegionIterator"
   "getQuantumDepth"
   "getQuantumRange"
   "getReleaseDate"
   "getResource"
   "getResourceLimit"
   "getSamplingFactors"
   "getSizeOffset"
   "getVersion"
   "hasNextImage"
   "hasPreviousImage"
   "identifyImage"
   "implodeImage"
   "labelImage"
   "levelImage"
   "linearStretchImage"
   "magnifyImage"
   "matteFloodfillImage"
   "medianFilterImage"
   "minifyImage"
   "modulateImage"
   "montageImage"
   "morphImages"
   "mosaicImages"
   "motionBlurImage"
   "negateImage"
   "newImage"
   "newPseudoImage"
   "nextImage"
   "normalizeImage"
   "oilPaintImage"
   "optimizeImageLayers"
   "paintOpaqueImage"
   "paintTransparentImage"
   "pingImage"
   "pingImageBlob"
   "pingImageFile"
   "polaroidImage"
   "posterizeImage"
   "previousImage"
   "profileImage"
   "queryFontMetrics"
   "queryFonts"
   "queryFormats"
   "radialBlurImage"
   "raiseImage"
   "randomThresholdImage"
   "readImage"
   "readImageBlob"
   "readImageFile"
   "reduceNoiseImage"
   "removeImage"
   "removeImageProfile"
   "render"
   "resampleImage"
   "resizeImage"
   "rollImage"
   "rotateImage"
   "roundCorners"
   "sampleImage"
   "scaleImage"
   "separateImageChannel"
   "sepiaToneImage"
   "setBackgroundColor"
   "setCompression"
   "setCompressionQuality"
   "setFilename"
   "setFirstIterator"
   "setFormat"
   "setImageBackgroundColor"
   "setImageBias"
   "setImageBluePrimary"
   "setImageBorderColor"
   "setImageChannelDepth"
   "setImageColormapColor"
   "setImageColorspace"
   "setImageCompose"
   "setImageCompression"
   "setImageDelay"
   "setImageDepth"
   "setImageDispose"
   "setImageExtent"
   "setImageFilename"
   "setImageFormat"
   "setImageGamma"
   "setImageGreenPrimary"
   "setImageIndex"
   "setImageInterlaceScheme"
   "setImageInterpolateMethod"
   "setImageIterations"
   "setImageMatte"
   "setImageMatteColor"
   "setImagePage"
   "setImageProfile"
   "setImageProperty"
   "setImageRedPrimary"
   "setImageRenderingIntent"
   "setImageResolution"
   "setImageScene"
   "setImageTicksPerSecond"
   "setImageType"
   "setImageUnits"
   "setImageVirtualPixelMethod"
   "setImageWhitePoint"
   "setInterlaceScheme"
   "setOption"
   "setPage"
   "setResolution"
   "setResourceLimit"
   "setSamplingFactors"
   "setSizeOffset"
   "shadeImage"
   "shadowImage"
   "sharpenImage"
   "shaveImage"
   "shearImage"
   "sigmoidalContrastImage"
   "sketchImage"
   "solarizeImage"
   "spliceImage"
   "spreadImage"
   "steganoImage"
   "stereoImage"
   "stripImage"
   "swirlImage"
   "textureImage"
   "thresholdImage"
   "thumbnailImage"
   "tintImage"
   "transverseImage"
   "trimImage"
   "uniqueImageColors"
   "unsharpMaskImage"
   "vignetteImage"
   "waveImage"
   "whiteThresholdImage"
   "writeImage"
   "writeImages"
   "affine"
   "annotation"
   "bezier"
   "color"
   "comment"
   "composite"
   "getClipPath"
   "getClipRule"
   "getClipUnits"
   "getFillColor"
   "getFillOpacity"
   "getFillRule"
   "getFontFamily"
   "getFontSize"
   "getFontStyle"
   "getFontWeight"
   "getGravity"
   "getStrokeAntialias"
   "getStrokeColor"
   "getStrokeDashArray"
   "getStrokeDashOffset"
   "getStrokeLineCap"
   "getStrokeLineJoin"
   "getStrokeMiterLimit"
   "getStrokeOpacity"
   "getStrokeWidth"
   "getTextAlignment"
   "getTextAntialias"
   "getTextDecoration"
   "getTextEncoding"
   "getTextUnderColor"
   "getVectorGraphics"
   "line"
   "matte"
   "pathClose"
   "pathCurveToAbsolute"
   "pathCurveToQuadraticBezierAbsolute"
   "pathCurveToQuadraticBezierRelative"
   "pathCurveToQuadraticBezierSmoothAbsolute"
   "pathCurveToQuadraticBezierSmoothRelative"
   "pathCurveToRelative"
   "pathCurveToSmoothAbsolute"
   "pathCurveToSmoothRelative"
   "pathEllipticArcAbsolute"
   "pathEllipticArcRelative"
   "pathFinish"
   "pathLineToAbsolute"
   "pathLineToHorizontalAbsolute"
   "pathLineToHorizontalRelative"
   "pathLineToRelative"
   "pathLineToVerticalAbsolute"
   "pathLineToVerticalRelative"
   "pathMoveToAbsolute"
   "pathMoveToRelative"
   "pathStart"
   "point"
   "polygon"
   "polyline"
   "pop"
   "popClipPath"
   "popDefs"
   "popPattern"
   "push"
   "pushClipPath"
   "pushDefs"
   "pushPattern"
   "rotate"
   "roundRectangle"
   "scale"
   "setClipPath"
   "setClipRule"
   "setClipUnits"
   "setFillAlpha"
   "setFillColor"
   "setFillOpacity"
   "setFillPatternURL"
   "setFillRule"
   "setFont"
   "setFontFamily"
   "setFontSize"
   "setFontStretch"
   "setFontStyle"
   "setFontWeight"
   "setGravity"
   "setStrokeAlpha"
   "setStrokeAntialias"
   "setStrokeColor"
   "setStrokeDashArray"
   "setStrokeDashOffset"
   "setStrokeLineCap"
   "setStrokeLineJoin"
   "setStrokeMiterLimit"
   "setStrokeOpacity"
   "setStrokePatternURL"
   "setStrokeWidth"
   "setTextAlignment"
   "setTextAntialias"
   "setTextDecoration"
   "setTextEncoding"
   "setTextUnderColor"
   "setVectorGraphics"
   "setViewbox"
   "skewX"
   "skewY"
   "translate"
   "getColor"
   "getColorCount"
   "getColorValue"
   "getHSL"
   "isSimilar"
   "setColor"
   "setColorValue"
   "setHSL"
   "getCurrentIteratorRow"
   "getIteratorRow"
   "getNextIteratorRow"
   "getPreviousIteratorRow"
   "newPixelIterator"
   "newPixelRegionIterator"
   "resetIterator"
   "setIteratorFirstRow"
   "setIteratorLastRow"
   "setIteratorRow"
   "syncIterator"
   "imap_8bit"
   "imap_alerts"
   "imap_append"
   "imap_base64"
   "imap_binary"
   "imap_body"
   "imap_bodystruct"
   "imap_check"
   "imap_clearflag_full"
   "imap_close"
   "imap_createmailbox"
   "imap_delete"
   "imap_deletemailbox"
   "imap_errors"
   "imap_expunge"
   "imap_fetch_overview"
   "imap_fetchbody"
   "imap_fetchheader"
   "imap_fetchstructure"
   "imap_get_quota"
   "imap_get_quotaroot"
   "imap_getacl"
   "imap_getmailboxes"
   "imap_getsubscribed"
   "imap_header"
   "imap_headerinfo"
   "imap_headers"
   "imap_last_error"
   "imap_list"
   "imap_listmailbox"
   "imap_listscan"
   "imap_listsubscribed"
   "imap_lsub"
   "imap_mail"
   "imap_mail_compose"
   "imap_mail_copy"
   "imap_mail_move"
   "imap_mailboxmsginfo"
   "imap_mime_header_decode"
   "imap_msgno"
   "imap_num_msg"
   "imap_num_recent"
   "imap_open"
   "imap_ping"
   "imap_qprint"
   "imap_renamemailbox"
   "imap_reopen"
   "imap_rfc822_parse_adrlist"
   "imap_rfc822_parse_headers"
   "imap_rfc822_write_address"
   "imap_savebody"
   "imap_scanmailbox"
   "imap_search"
   "imap_set_quota"
   "imap_setacl"
   "imap_setflag_full"
   "imap_sort"
   "imap_status"
   "imap_subscribe"
   "imap_thread"
   "imap_timeout"
   "imap_uid"
   "imap_undelete"
   "imap_unsubscribe"
   "imap_utf7_decode"
   "imap_utf7_encode"
   "imap_utf8"
   "implode"
   "import_request_variables"
   "in_array"
   "inet_ntop"
   "inet_pton"
   "ingres_autocommit"
   "ingres_close"
   "ingres_commit"
   "ingres_connect"
   "ingres_cursor"
   "ingres_errno"
   "ingres_error"
   "ingres_errsqlstate"
   "ingres_fetch_array"
   "ingres_fetch_object"
   "ingres_fetch_row"
   "ingres_field_length"
   "ingres_field_name"
   "ingres_field_nullable"
   "ingres_field_precision"
   "ingres_field_scale"
   "ingres_field_type"
   "ingres_num_fields"
   "ingres_num_rows"
   "ingres_pconnect"
   "ingres_query"
   "ingres_rollback"
   "ini_alter"
   "ini_get"
   "ini_get_all"
   "ini_restore"
   "ini_set"
   "interface_exists"
   "intval"
   "ip2long"
   "iptcembed"
   "iptcparse"
   "is_a"
   "is_array"
   "is_binary"
   "is_bool"
   "is_buffer"
   "is_callable"
   "is_dir"
   "is_double"
   "is_executable"
   "is_file"
   "is_finite"
   "is_float"
   "is_infinite"
   "is_int"
   "is_integer"
   "is_link"
   "is_long"
   "is_nan"
   "is_null"
   "is_numeric"
   "is_object"
   "is_readable"
   "is_real"
   "is_resource"
   "is_scalar"
   "is_soap_fault"
   "is_string"
   "is_subclass_of"
   "is_unicode"
   "is_uploaded_file"
   "is_writable"
   "is_writeable"
   "isset"
   "iterator_count"
   "iterator_to_array"
   "java_last_exception_clear"
   "java_last_exception_get"
   "jddayofweek"
   "jdmonthname"
   "jdtofrench"
   "jdtogregorian"
   "jdtojewish"
   "jdtojulian"
   "jdtounix"
   "jewishtojd"
   "join"
   "jpeg2wbmp"
   "json_decode"
   "json_encode"
   "juliantojd"
   "kadm5_chpass_principal"
   "kadm5_create_principal"
   "kadm5_delete_principal"
   "kadm5_destroy"
   "kadm5_flush"
   "kadm5_get_policies"
   "kadm5_get_principal"
   "kadm5_get_principals"
   "kadm5_init_with_password"
   "kadm5_modify_principal"
   "krsort"
   "ksort"
   "lcg_value"
   "lchgrp"
   "lchown"
   "ldap_8859_to_t61"
   "ldap_add"
   "ldap_bind"
   "ldap_close"
   "ldap_compare"
   "ldap_connect"
   "ldap_count_entries"
   "ldap_delete"
   "ldap_dn2ufn"
   "ldap_err2str"
   "ldap_errno"
   "ldap_error"
   "ldap_explode_dn"
   "ldap_first_attribute"
   "ldap_first_entry"
   "ldap_first_reference"
   "ldap_free_result"
   "ldap_get_attributes"
   "ldap_get_dn"
   "ldap_get_entries"
   "ldap_get_option"
   "ldap_get_values"
   "ldap_get_values_len"
   "ldap_list"
   "ldap_mod_add"
   "ldap_mod_del"
   "ldap_mod_replace"
   "ldap_modify"
   "ldap_next_attribute"
   "ldap_next_entry"
   "ldap_next_reference"
   "ldap_parse_reference"
   "ldap_parse_result"
   "ldap_read"
   "ldap_rename"
   "ldap_sasl_bind"
   "ldap_search"
   "ldap_set_option"
   "ldap_set_rebind_proc"
   "ldap_sort"
   "ldap_start_tls"
   "ldap_t61_to_8859"
   "ldap_unbind"
   "levenshtein"
   "libxml_clear_errors"
   "libxml_get_errors"
   "libxml_get_last_error"
   "libxml_set_streams_context"
   "libxml_use_internal_errors"
   "getPosition"
   "linkinfo"
   "list"
   "locale_get_default"
   "locale_set_default"
   "localeconv"
   "localtime"
   "log"
   "log10"
   "log1p"
   "long2ip"
   "lstat"
   "ltrim"
   "lzf_compress"
   "lzf_decompress"
   "lzf_optimized_for"
   "m_checkstatus"
   "m_completeauthorizations"
   "m_connect"
   "m_connectionerror"
   "m_deletetrans"
   "m_destroyconn"
   "m_destroyengine"
   "m_getcell"
   "m_getcellbynum"
   "m_getcommadelimited"
   "m_getheader"
   "m_initconn"
   "m_initengine"
   "m_iscommadelimited"
   "m_maxconntimeout"
   "m_monitor"
   "m_numcolumns"
   "m_numrows"
   "m_parsecommadelimited"
   "m_responsekeys"
   "m_responseparam"
   "m_returnstatus"
   "m_setblocking"
   "m_setdropfile"
   "m_setip"
   "m_setssl"
   "m_setssl_cafile"
   "m_setssl_files"
   "m_settimeout"
   "m_sslcert_gen_hash"
   "m_transactionssent"
   "m_transinqueue"
   "m_transkeyval"
   "m_transnew"
   "m_transsend"
   "m_uwait"
   "m_validateidentifier"
   "m_verifyconnection"
   "m_verifysslcert"
   "mail"
   "mailparse_determine_best_xfer_encoding"
   "mailparse_msg_create"
   "mailparse_msg_extract_part"
   "mailparse_msg_extract_part_file"
   "mailparse_msg_extract_whole_part_file"
   "mailparse_msg_free"
   "mailparse_msg_get_part"
   "mailparse_msg_get_part_data"
   "mailparse_msg_get_structure"
   "mailparse_msg_parse"
   "mailparse_msg_parse_file"
   "mailparse_rfc822_parse_addresses"
   "mailparse_stream_encode"
   "mailparse_uudecode_all"
   "main"
   "max"
   "maxdb"
   "affected_rows"
   "auto_commit"
   "change_user"
   "character_set_name"
   "close"
   "close_long_data"
   "commit"
   "disable_reads_from_master"
   "errno"
   "fetch_assoc"
   "field_count"
   "get_host_info"
   "insert_id"
   "kill"
   "more_results"
   "multi_query"
   "next_result"
   "options"
   "ping"
   "prepare"
   "protocol_version"
   "real_connect"
   "real_escape_string"
   "real_query"
   "rollback"
   "rpl_query_type"
   "select_db"
   "send_query"
   "server_info"
   "sqlstate"
   "ssl_set"
   "stat"
   "stmt_init"
   "store_result"
   "thread_id"
   "use_result"
   "warning_count"
   "maxdb_affected_rows"
   "maxdb_autocommit"
   "maxdb_bind_param"
   "maxdb_bind_result"
   "maxdb_change_user"
   "maxdb_character_set_name"
   "maxdb_client_encoding"
   "maxdb_close"
   "maxdb_close_long_data"
   "maxdb_commit"
   "maxdb_connect"
   "maxdb_connect_errno"
   "maxdb_connect_error"
   "maxdb_data_seek"
   "maxdb_debug"
   "maxdb_disable_reads_from_master"
   "maxdb_disable_rpl_parse"
   "maxdb_dump_debug_info"
   "maxdb_embedded_connect"
   "maxdb_enable_reads_from_master"
   "maxdb_enable_rpl_parse"
   "maxdb_errno"
   "maxdb_error"
   "maxdb_escape_string"
   "maxdb_execute"
   "maxdb_fetch"
   "maxdb_fetch_array"
   "maxdb_fetch_assoc"
   "maxdb_fetch_field"
   "maxdb_fetch_field_direct"
   "maxdb_fetch_fields"
   "maxdb_fetch_lengths"
   "maxdb_fetch_object"
   "maxdb_fetch_row"
   "maxdb_field_count"
   "maxdb_field_seek"
   "maxdb_field_tell"
   "maxdb_free_result"
   "maxdb_get_client_info"
   "maxdb_get_client_version"
   "maxdb_get_host_info"
   "maxdb_get_metadata"
   "maxdb_get_proto_info"
   "maxdb_get_server_info"
   "maxdb_get_server_version"
   "maxdb_info"
   "maxdb_init"
   "maxdb_insert_id"
   "maxdb_kill"
   "maxdb_master_query"
   "maxdb_more_results"
   "maxdb_multi_query"
   "maxdb_next_result"
   "maxdb_num_fields"
   "maxdb_num_rows"
   "maxdb_options"
   "maxdb_param_count"
   "maxdb_ping"
   "maxdb_prepare"
   "maxdb_query"
   "maxdb_real_connect"
   "maxdb_real_escape_string"
   "maxdb_real_query"
   "maxdb_report"
   "maxdb_rollback"
   "maxdb_rpl_parse_enabled"
   "maxdb_rpl_probe"
   "maxdb_rpl_query_type"
   "maxdb_select_db"
   "maxdb_send_long_data"
   "maxdb_send_query"
   "maxdb_server_end"
   "maxdb_server_init"
   "maxdb_set_opt"
   "maxdb_sqlstate"
   "maxdb_ssl_set"
   "maxdb_stat"
   "error"
   "maxdb_stmt_affected_rows"
   "maxdb_stmt_bind_param"
   "maxdb_stmt_bind_result"
   "maxdb_stmt_close"
   "maxdb_stmt_close_long_data"
   "maxdb_stmt_data_seek"
   "maxdb_stmt_errno"
   "maxdb_stmt_error"
   "maxdb_stmt_execute"
   "maxdb_stmt_fetch"
   "maxdb_stmt_free_result"
   "maxdb_stmt_init"
   "maxdb_stmt_num_rows"
   "maxdb_stmt_param_count"
   "maxdb_stmt_prepare"
   "maxdb_stmt_reset"
   "maxdb_stmt_result_metadata"
   "maxdb_stmt_send_long_data"
   "maxdb_stmt_sqlstate"
   "maxdb_stmt_store_result"
   "maxdb_store_result"
   "maxdb_thread_id"
   "maxdb_thread_safe"
   "maxdb_use_result"
   "maxdb_warning_count"
   "mb_check_encoding"
   "mb_convert_case"
   "mb_convert_encoding"
   "mb_convert_kana"
   "mb_convert_variables"
   "mb_decode_mimeheader"
   "mb_decode_numericentity"
   "mb_detect_encoding"
   "mb_detect_order"
   "mb_encode_mimeheader"
   "mb_encode_numericentity"
   "mb_ereg"
   "mb_ereg_match"
   "mb_ereg_replace"
   "mb_ereg_search"
   "mb_ereg_search_getpos"
   "mb_ereg_search_getregs"
   "mb_ereg_search_init"
   "mb_ereg_search_pos"
   "mb_ereg_search_regs"
   "mb_ereg_search_setpos"
   "mb_eregi"
   "mb_eregi_replace"
   "mb_get_info"
   "mb_http_input"
   "mb_http_output"
   "mb_internal_encoding"
   "mb_language"
   "mb_output_handler"
   "mb_parse_str"
   "mb_preferred_mime_name"
   "mb_regex_encoding"
   "mb_regex_set_options"
   "mb_send_mail"
   "mb_split"
   "mb_strcut"
   "mb_strimwidth"
   "mb_stripos"
   "mb_stristr"
   "mb_strlen"
   "mb_strpos"
   "mb_strrchr"
   "mb_strrichr"
   "mb_strripos"
   "mb_strrpos"
   "mb_strstr"
   "mb_strtolower"
   "mb_strtoupper"
   "mb_strwidth"
   "mb_substitute_character"
   "mb_substr"
   "mb_substr_count"
   "mcrypt_cbc"
   "mcrypt_cfb"
   "mcrypt_create_iv"
   "mcrypt_decrypt"
   "mcrypt_ecb"
   "mcrypt_enc_get_algorithms_name"
   "mcrypt_enc_get_block_size"
   "mcrypt_enc_get_iv_size"
   "mcrypt_enc_get_key_size"
   "mcrypt_enc_get_modes_name"
   "mcrypt_enc_get_supported_key_sizes"
   "mcrypt_enc_is_block_algorithm"
   "mcrypt_enc_is_block_algorithm_mode"
   "mcrypt_enc_is_block_mode"
   "mcrypt_enc_self_test"
   "mcrypt_encrypt"
   "mcrypt_generic"
   "mcrypt_generic_deinit"
   "mcrypt_generic_end"
   "mcrypt_generic_init"
   "mcrypt_get_block_size"
   "mcrypt_get_cipher_name"
   "mcrypt_get_iv_size"
   "mcrypt_get_key_size"
   "mcrypt_list_algorithms"
   "mcrypt_list_modes"
   "mcrypt_module_close"
   "mcrypt_module_get_algo_block_size"
   "mcrypt_module_get_algo_key_size"
   "mcrypt_module_get_supported_key_sizes"
   "mcrypt_module_is_block_algorithm"
   "mcrypt_module_is_block_algorithm_mode"
   "mcrypt_module_is_block_mode"
   "mcrypt_module_open"
   "mcrypt_module_self_test"
   "mcrypt_ofb"
   "md5"
   "md5_file"
   "mdecrypt_generic"
   "add"
   "addServer"
   "connect"
   "decrement"
   "getExtendedStats"
   "getServerStatus"
   "getStats"
   "increment"
   "pconnect"
   "setCompressThreshold"
   "setServerParams"
   "memcache_debug"
   "memory_get_peak_usage"
   "memory_get_usage"
   "metaphone"
   "method_exists"
   "mhash"
   "mhash_count"
   "mhash_get_block_size"
   "mhash_get_hash_name"
   "mhash_keygen_s2k"
   "microtime"
   "mime_content_type"
   "min"
   "ming_keypress"
   "ming_setcubicthreshold"
   "ming_setscale"
   "ming_setswfcompression"
   "ming_useconstants"
   "ming_useswfversion"
   "mkdir"
   "mktime"
   "money_format"
   "move_uploaded_file"
   "msession_connect"
   "msession_count"
   "msession_create"
   "msession_destroy"
   "msession_disconnect"
   "msession_find"
   "msession_get"
   "msession_get_array"
   "msession_get_data"
   "msession_inc"
   "msession_list"
   "msession_listvar"
   "msession_lock"
   "msession_plugin"
   "msession_randstr"
   "msession_set"
   "msession_set_array"
   "msession_set_data"
   "msession_timeout"
   "msession_uniq"
   "msession_unlock"
   "msg_get_queue"
   "msg_receive"
   "msg_remove_queue"
   "msg_send"
   "msg_set_queue"
   "msg_stat_queue"
   "msql"
   "msql_affected_rows"
   "msql_close"
   "msql_connect"
   "msql_create_db"
   "msql_createdb"
   "msql_data_seek"
   "msql_db_query"
   "msql_dbname"
   "msql_drop_db"
   "msql_error"
   "msql_fetch_array"
   "msql_fetch_field"
   "msql_fetch_object"
   "msql_fetch_row"
   "msql_field_flags"
   "msql_field_len"
   "msql_field_name"
   "msql_field_seek"
   "msql_field_table"
   "msql_field_type"
   "msql_fieldflags"
   "msql_fieldlen"
   "msql_fieldname"
   "msql_fieldtable"
   "msql_fieldtype"
   "msql_free_result"
   "msql_list_dbs"
   "msql_list_fields"
   "msql_list_tables"
   "msql_num_fields"
   "msql_num_rows"
   "msql_numfields"
   "msql_numrows"
   "msql_pconnect"
   "msql_query"
   "msql_regcase"
   "msql_result"
   "msql_select_db"
   "msql_tablename"
   "mssql_bind"
   "mssql_close"
   "mssql_connect"
   "mssql_data_seek"
   "mssql_execute"
   "mssql_fetch_array"
   "mssql_fetch_assoc"
   "mssql_fetch_batch"
   "mssql_fetch_field"
   "mssql_fetch_object"
   "mssql_fetch_row"
   "mssql_field_length"
   "mssql_field_name"
   "mssql_field_seek"
   "mssql_field_type"
   "mssql_free_result"
   "mssql_free_statement"
   "mssql_get_last_message"
   "mssql_guid_string"
   "mssql_init"
   "mssql_min_error_severity"
   "mssql_min_message_severity"
   "mssql_next_result"
   "mssql_num_fields"
   "mssql_num_rows"
   "mssql_pconnect"
   "mssql_query"
   "mssql_result"
   "mssql_rows_affected"
   "mssql_select_db"
   "mt_getrandmax"
   "mt_rand"
   "mt_srand"
   "mysql_affected_rows"
   "mysql_change_user"
   "mysql_client_encoding"
   "mysql_close"
   "mysql_connect"
   "mysql_create_db"
   "mysql_data_seek"
   "mysql_db_name"
   "mysql_db_query"
   "mysql_drop_db"
   "mysql_errno"
   "mysql_error"
   "mysql_escape_string"
   "mysql_fetch_array"
   "mysql_fetch_assoc"
   "mysql_fetch_field"
   "mysql_fetch_lengths"
   "mysql_fetch_object"
   "mysql_fetch_row"
   "mysql_field_flags"
   "mysql_field_len"
   "mysql_field_name"
   "mysql_field_seek"
   "mysql_field_table"
   "mysql_field_type"
   "mysql_free_result"
   "mysql_get_client_info"
   "mysql_get_host_info"
   "mysql_get_proto_info"
   "mysql_get_server_info"
   "mysql_info"
   "mysql_insert_id"
   "mysql_list_dbs"
   "mysql_list_fields"
   "mysql_list_processes"
   "mysql_list_tables"
   "mysql_num_fields"
   "mysql_num_rows"
   "mysql_pconnect"
   "mysql_ping"
   "mysql_query"
   "mysql_real_escape_string"
   "mysql_result"
   "mysql_select_db"
   "mysql_set_charset"
   "mysql_stat"
   "mysql_tablename"
   "mysql_thread_id"
   "mysql_unbuffered_query"
   "autocommit"
   "debug"
   "dump_debug_info"
   "host_info"
   "server_version"
   "set_charset"
   "mysqli_affected_rows"
   "mysqli_autocommit"
   "mysqli_bind_param"
   "mysqli_bind_result"
   "mysqli_change_user"
   "mysqli_character_set_name"
   "mysqli_client_encoding"
   "mysqli_close"
   "mysqli_commit"
   "mysqli_connect"
   "mysqli_connect_errno"
   "mysqli_connect_error"
   "mysqli_data_seek"
   "mysqli_debug"
   "mysqli_disable_reads_from_master"
   "mysqli_disable_rpl_parse"
   "mysqli_dump_debug_info"
   "mysqli_embedded_server_end"
   "mysqli_embedded_server_start"
   "mysqli_enable_reads_from_master"
   "mysqli_enable_rpl_parse"
   "mysqli_errno"
   "mysqli_error"
   "mysqli_escape_string"
   "mysqli_execute"
   "mysqli_fetch"
   "mysqli_fetch_array"
   "mysqli_fetch_assoc"
   "mysqli_fetch_field"
   "mysqli_fetch_field_direct"
   "mysqli_fetch_fields"
   "mysqli_fetch_lengths"
   "mysqli_fetch_object"
   "mysqli_fetch_row"
   "mysqli_field_count"
   "mysqli_field_seek"
   "mysqli_field_tell"
   "mysqli_free_result"
   "mysqli_get_charset"
   "mysqli_get_client_info"
   "mysqli_get_client_version"
   "mysqli_get_host_info"
   "mysqli_get_metadata"
   "mysqli_get_proto_info"
   "mysqli_get_server_info"
   "mysqli_get_server_version"
   "mysqli_get_warnings"
   "mysqli_info"
   "mysqli_init"
   "mysqli_insert_id"
   "mysqli_kill"
   "mysqli_master_query"
   "mysqli_more_results"
   "mysqli_multi_query"
   "mysqli_next_result"
   "mysqli_num_fields"
   "mysqli_num_rows"
   "mysqli_options"
   "mysqli_param_count"
   "mysqli_ping"
   "mysqli_prepare"
   "mysqli_query"
   "mysqli_real_connect"
   "mysqli_real_escape_string"
   "mysqli_real_query"
   "mysqli_report"
   "mysqli_rollback"
   "mysqli_rpl_parse_enabled"
   "mysqli_rpl_probe"
   "mysqli_rpl_query_type"
   "mysqli_select_db"
   "mysqli_send_long_data"
   "mysqli_send_query"
   "mysqli_set_charset"
   "mysqli_set_local_infile_default"
   "mysqli_set_local_infile_handler"
   "mysqli_set_opt"
   "mysqli_slave_query"
   "mysqli_sqlstate"
   "mysqli_ssl_set"
   "mysqli_stat"
   "mysqli_stmt_affected_rows"
   "mysqli_stmt_attr_get"
   "mysqli_stmt_attr_set"
   "mysqli_stmt_bind_param"
   "mysqli_stmt_bind_result"
   "mysqli_stmt_close"
   "mysqli_stmt_data_seek"
   "mysqli_stmt_errno"
   "mysqli_stmt_error"
   "mysqli_stmt_execute"
   "mysqli_stmt_fetch"
   "mysqli_stmt_field_count"
   "mysqli_stmt_free_result"
   "mysqli_stmt_get_warnings"
   "mysqli_stmt_init"
   "mysqli_stmt_insert_id"
   "mysqli_stmt_num_rows"
   "mysqli_stmt_param_count"
   "mysqli_stmt_prepare"
   "mysqli_stmt_reset"
   "mysqli_stmt_result_metadata"
   "mysqli_stmt_send_long_data"
   "mysqli_stmt_sqlstate"
   "mysqli_stmt_store_result"
   "mysqli_store_result"
   "mysqli_thread_id"
   "mysqli_thread_safe"
   "mysqli_use_result"
   "mysqli_warning_count"
   "natcasesort"
   "natsort"
   "ncurses_addch"
   "ncurses_addchnstr"
   "ncurses_addchstr"
   "ncurses_addnstr"
   "ncurses_addstr"
   "ncurses_assume_default_colors"
   "ncurses_attroff"
   "ncurses_attron"
   "ncurses_attrset"
   "ncurses_baudrate"
   "ncurses_beep"
   "ncurses_bkgd"
   "ncurses_bkgdset"
   "ncurses_border"
   "ncurses_bottom_panel"
   "ncurses_can_change_color"
   "ncurses_cbreak"
   "ncurses_clear"
   "ncurses_clrtobot"
   "ncurses_clrtoeol"
   "ncurses_color_content"
   "ncurses_color_set"
   "ncurses_curs_set"
   "ncurses_def_prog_mode"
   "ncurses_def_shell_mode"
   "ncurses_define_key"
   "ncurses_del_panel"
   "ncurses_delay_output"
   "ncurses_delch"
   "ncurses_deleteln"
   "ncurses_delwin"
   "ncurses_doupdate"
   "ncurses_echo"
   "ncurses_echochar"
   "ncurses_end"
   "ncurses_erase"
   "ncurses_erasechar"
   "ncurses_filter"
   "ncurses_flash"
   "ncurses_flushinp"
   "ncurses_getch"
   "ncurses_getmaxyx"
   "ncurses_getmouse"
   "ncurses_getyx"
   "ncurses_halfdelay"
   "ncurses_has_colors"
   "ncurses_has_ic"
   "ncurses_has_il"
   "ncurses_has_key"
   "ncurses_hide_panel"
   "ncurses_hline"
   "ncurses_inch"
   "ncurses_init"
   "ncurses_init_color"
   "ncurses_init_pair"
   "ncurses_insch"
   "ncurses_insdelln"
   "ncurses_insertln"
   "ncurses_insstr"
   "ncurses_instr"
   "ncurses_isendwin"
   "ncurses_keyok"
   "ncurses_keypad"
   "ncurses_killchar"
   "ncurses_longname"
   "ncurses_meta"
   "ncurses_mouse_trafo"
   "ncurses_mouseinterval"
   "ncurses_mousemask"
   "ncurses_move"
   "ncurses_move_panel"
   "ncurses_mvaddch"
   "ncurses_mvaddchnstr"
   "ncurses_mvaddchstr"
   "ncurses_mvaddnstr"
   "ncurses_mvaddstr"
   "ncurses_mvcur"
   "ncurses_mvdelch"
   "ncurses_mvgetch"
   "ncurses_mvhline"
   "ncurses_mvinch"
   "ncurses_mvvline"
   "ncurses_mvwaddstr"
   "ncurses_napms"
   "ncurses_new_panel"
   "ncurses_newpad"
   "ncurses_newwin"
   "ncurses_nl"
   "ncurses_nocbreak"
   "ncurses_noecho"
   "ncurses_nonl"
   "ncurses_noqiflush"
   "ncurses_noraw"
   "ncurses_pair_content"
   "ncurses_panel_above"
   "ncurses_panel_below"
   "ncurses_panel_window"
   "ncurses_pnoutrefresh"
   "ncurses_prefresh"
   "ncurses_putp"
   "ncurses_qiflush"
   "ncurses_raw"
   "ncurses_refresh"
   "ncurses_replace_panel"
   "ncurses_reset_prog_mode"
   "ncurses_reset_shell_mode"
   "ncurses_resetty"
   "ncurses_savetty"
   "ncurses_scr_dump"
   "ncurses_scr_init"
   "ncurses_scr_restore"
   "ncurses_scr_set"
   "ncurses_scrl"
   "ncurses_show_panel"
   "ncurses_slk_attr"
   "ncurses_slk_attroff"
   "ncurses_slk_attron"
   "ncurses_slk_attrset"
   "ncurses_slk_clear"
   "ncurses_slk_color"
   "ncurses_slk_init"
   "ncurses_slk_noutrefresh"
   "ncurses_slk_refresh"
   "ncurses_slk_restore"
   "ncurses_slk_set"
   "ncurses_slk_touch"
   "ncurses_standend"
   "ncurses_standout"
   "ncurses_start_color"
   "ncurses_termattrs"
   "ncurses_termname"
   "ncurses_timeout"
   "ncurses_top_panel"
   "ncurses_typeahead"
   "ncurses_ungetch"
   "ncurses_ungetmouse"
   "ncurses_update_panels"
   "ncurses_use_default_colors"
   "ncurses_use_env"
   "ncurses_use_extended_names"
   "ncurses_vidattr"
   "ncurses_vline"
   "ncurses_waddch"
   "ncurses_waddstr"
   "ncurses_wattroff"
   "ncurses_wattron"
   "ncurses_wattrset"
   "ncurses_wborder"
   "ncurses_wclear"
   "ncurses_wcolor_set"
   "ncurses_werase"
   "ncurses_wgetch"
   "ncurses_whline"
   "ncurses_wmouse_trafo"
   "ncurses_wmove"
   "ncurses_wnoutrefresh"
   "ncurses_wrefresh"
   "ncurses_wstandend"
   "ncurses_wstandout"
   "ncurses_wvline"
   "newt_bell"
   "newt_button"
   "newt_button_bar"
   "newt_centered_window"
   "newt_checkbox"
   "newt_checkbox_get_value"
   "newt_checkbox_set_flags"
   "newt_checkbox_set_value"
   "newt_checkbox_tree"
   "newt_checkbox_tree_add_item"
   "newt_checkbox_tree_find_item"
   "newt_checkbox_tree_get_current"
   "newt_checkbox_tree_get_entry_value"
   "newt_checkbox_tree_get_multi_selection"
   "newt_checkbox_tree_get_selection"
   "newt_checkbox_tree_multi"
   "newt_checkbox_tree_set_current"
   "newt_checkbox_tree_set_entry"
   "newt_checkbox_tree_set_entry_value"
   "newt_checkbox_tree_set_width"
   "newt_clear_key_buffer"
   "newt_cls"
   "newt_compact_button"
   "newt_component_add_callback"
   "newt_component_takes_focus"
   "newt_create_grid"
   "newt_cursor_off"
   "newt_cursor_on"
   "newt_delay"
   "newt_draw_form"
   "newt_draw_root_text"
   "newt_entry"
   "newt_entry_get_value"
   "newt_entry_set"
   "newt_entry_set_filter"
   "newt_entry_set_flags"
   "newt_finished"
   "newt_form"
   "newt_form_add_component"
   "newt_form_add_components"
   "newt_form_add_hot_key"
   "newt_form_destroy"
   "newt_form_get_current"
   "newt_form_run"
   "newt_form_set_background"
   "newt_form_set_height"
   "newt_form_set_size"
   "newt_form_set_timer"
   "newt_form_set_width"
   "newt_form_watch_fd"
   "newt_get_screen_size"
   "newt_grid_add_components_to_form"
   "newt_grid_basic_window"
   "newt_grid_free"
   "newt_grid_get_size"
   "newt_grid_h_close_stacked"
   "newt_grid_h_stacked"
   "newt_grid_place"
   "newt_grid_set_field"
   "newt_grid_simple_window"
   "newt_grid_v_close_stacked"
   "newt_grid_v_stacked"
   "newt_grid_wrapped_window"
   "newt_grid_wrapped_window_at"
   "newt_init"
   "newt_label"
   "newt_label_set_text"
   "newt_listbox"
   "newt_listbox_append_entry"
   "newt_listbox_clear"
   "newt_listbox_clear_selection"
   "newt_listbox_delete_entry"
   "newt_listbox_get_current"
   "newt_listbox_get_selection"
   "newt_listbox_insert_entry"
   "newt_listbox_item_count"
   "newt_listbox_select_item"
   "newt_listbox_set_current"
   "newt_listbox_set_current_by_key"
   "newt_listbox_set_data"
   "newt_listbox_set_entry"
   "newt_listbox_set_width"
   "newt_listitem"
   "newt_listitem_get_data"
   "newt_listitem_set"
   "newt_open_window"
   "newt_pop_help_line"
   "newt_pop_window"
   "newt_push_help_line"
   "newt_radio_get_current"
   "newt_radiobutton"
   "newt_redraw_help_line"
   "newt_reflow_text"
   "newt_refresh"
   "newt_resize_screen"
   "newt_resume"
   "newt_run_form"
   "newt_scale"
   "newt_scale_set"
   "newt_scrollbar_set"
   "newt_set_help_callback"
   "newt_set_suspend_callback"
   "newt_suspend"
   "newt_textbox"
   "newt_textbox_get_num_lines"
   "newt_textbox_reflowed"
   "newt_textbox_set_height"
   "newt_textbox_set_text"
   "newt_vertical_scrollbar"
   "newt_wait_for_key"
   "newt_win_choice"
   "newt_win_entries"
   "newt_win_menu"
   "newt_win_message"
   "newt_win_messagev"
   "newt_win_ternary"
   "ngettext"
   "nl2br"
   "nl_langinfo"
   "notes_body"
   "notes_copy_db"
   "notes_create_db"
   "notes_create_note"
   "notes_drop_db"
   "notes_find_note"
   "notes_header_info"
   "notes_list_msgs"
   "notes_mark_read"
   "notes_mark_unread"
   "notes_nav_create"
   "notes_search"
   "notes_unread"
   "notes_version"
   "nsapi_request_headers"
   "nsapi_response_headers"
   "nsapi_virtual"
   "number_format"
   "ob_clean"
   "ob_deflatehandler"
   "ob_end_clean"
   "ob_end_flush"
   "ob_etaghandler"
   "ob_flush"
   "ob_get_clean"
   "ob_get_contents"
   "ob_get_flush"
   "ob_get_length"
   "ob_get_level"
   "ob_get_status"
   "ob_gzhandler"
   "ob_iconv_handler"
   "ob_implicit_flush"
   "ob_inflatehandler"
   "ob_list_handlers"
   "ob_start"
   "ob_tidyhandler"
   "assignElem"
   "free"
   "getElem"
   "size"
   "trim"
   "eof"
   "erase"
   "export"
   "getBuffering"
   "import"
   "saveFile"
   "setBuffering"
   "tell"
   "truncate"
   "write"
   "writeTemporary"
   "writeToFile"
   "oci_bind_array_by_name"
   "oci_bind_by_name"
   "oci_cancel"
   "oci_close"
   "oci_commit"
   "oci_connect"
   "oci_define_by_name"
   "oci_error"
   "oci_execute"
   "oci_fetch"
   "oci_fetch_all"
   "oci_fetch_array"
   "oci_fetch_assoc"
   "oci_fetch_object"
   "oci_fetch_row"
   "oci_field_is_null"
   "oci_field_name"
   "oci_field_precision"
   "oci_field_scale"
   "oci_field_size"
   "oci_field_type"
   "oci_field_type_raw"
   "oci_free_statement"
   "oci_internal_debug"
   "oci_lob_copy"
   "oci_lob_is_equal"
   "oci_new_collection"
   "oci_new_connect"
   "oci_new_cursor"
   "oci_new_descriptor"
   "oci_num_fields"
   "oci_num_rows"
   "oci_parse"
   "oci_password_change"
   "oci_pconnect"
   "oci_result"
   "oci_rollback"
   "oci_server_version"
   "oci_set_prefetch"
   "oci_statement_type"
   "ocibindbyname"
   "ocicancel"
   "ocicloselob"
   "ocicollappend"
   "ocicollassign"
   "ocicollassignelem"
   "ocicollgetelem"
   "ocicollmax"
   "ocicollsize"
   "ocicolltrim"
   "ocicolumnisnull"
   "ocicolumnname"
   "ocicolumnprecision"
   "ocicolumnscale"
   "ocicolumnsize"
   "ocicolumntype"
   "ocicolumntyperaw"
   "ocicommit"
   "ocidefinebyname"
   "ocierror"
   "ociexecute"
   "ocifetch"
   "ocifetchinto"
   "ocifetchstatement"
   "ocifreecollection"
   "ocifreecursor"
   "ocifreedesc"
   "ocifreestatement"
   "ociinternaldebug"
   "ociloadlob"
   "ocilogoff"
   "ocilogon"
   "ocinewcollection"
   "ocinewcursor"
   "ocinewdescriptor"
   "ocinlogon"
   "ocinumcols"
   "ociparse"
   "ociplogon"
   "ociresult"
   "ocirollback"
   "ocirowcount"
   "ocisavelob"
   "ocisavelobfile"
   "ociserverversion"
   "ocisetprefetch"
   "ocistatementtype"
   "ociwritelobtofile"
   "ociwritetemporarylob"
   "octdec"
   "odbc_autocommit"
   "odbc_binmode"
   "odbc_close"
   "odbc_close_all"
   "odbc_columnprivileges"
   "odbc_columns"
   "odbc_commit"
   "odbc_connect"
   "odbc_cursor"
   "odbc_data_source"
   "odbc_do"
   "odbc_error"
   "odbc_errormsg"
   "odbc_exec"
   "odbc_execute"
   "odbc_fetch_array"
   "odbc_fetch_into"
   "odbc_fetch_object"
   "odbc_fetch_row"
   "odbc_field_len"
   "odbc_field_name"
   "odbc_field_num"
   "odbc_field_precision"
   "odbc_field_scale"
   "odbc_field_type"
   "odbc_foreignkeys"
   "odbc_free_result"
   "odbc_gettypeinfo"
   "odbc_longreadlen"
   "odbc_next_result"
   "odbc_num_fields"
   "odbc_num_rows"
   "odbc_pconnect"
   "odbc_prepare"
   "odbc_primarykeys"
   "odbc_procedurecolumns"
   "odbc_procedures"
   "odbc_result"
   "odbc_result_all"
   "odbc_rollback"
   "odbc_setoption"
   "odbc_specialcolumns"
   "odbc_statistics"
   "odbc_tableprivileges"
   "odbc_tables"
   "openal_buffer_create"
   "openal_buffer_data"
   "openal_buffer_destroy"
   "openal_buffer_get"
   "openal_buffer_loadwav"
   "openal_context_create"
   "openal_context_current"
   "openal_context_destroy"
   "openal_context_process"
   "openal_context_suspend"
   "openal_device_close"
   "openal_device_open"
   "openal_listener_get"
   "openal_listener_set"
   "openal_source_create"
   "openal_source_destroy"
   "openal_source_get"
   "openal_source_pause"
   "openal_source_play"
   "openal_source_rewind"
   "openal_source_set"
   "openal_source_stop"
   "openal_stream"
   "opendir"
   "openlog"
   "openssl_csr_export"
   "openssl_csr_export_to_file"
   "openssl_csr_get_public_key"
   "openssl_csr_get_subject"
   "openssl_csr_new"
   "openssl_csr_sign"
   "openssl_error_string"
   "openssl_free_key"
   "openssl_get_privatekey"
   "openssl_get_publickey"
   "openssl_open"
   "openssl_pkcs7_decrypt"
   "openssl_pkcs7_encrypt"
   "openssl_pkcs7_sign"
   "openssl_pkcs7_verify"
   "openssl_pkey_export"
   "openssl_pkey_export_to_file"
   "openssl_pkey_free"
   "openssl_pkey_get_details"
   "openssl_pkey_get_private"
   "openssl_pkey_get_public"
   "openssl_pkey_new"
   "openssl_private_decrypt"
   "openssl_private_encrypt"
   "openssl_public_decrypt"
   "openssl_public_encrypt"
   "openssl_seal"
   "openssl_sign"
   "openssl_verify"
   "openssl_x509_check_private_key"
   "openssl_x509_checkpurpose"
   "openssl_x509_export"
   "openssl_x509_export_to_file"
   "openssl_x509_free"
   "openssl_x509_parse"
   "openssl_x509_read"
   "ord"
   "output_add_rewrite_var"
   "output_reset_rewrite_vars"
   "overload"
   "override_function"
   "ovrimos_close"
   "ovrimos_commit"
   "ovrimos_connect"
   "ovrimos_cursor"
   "ovrimos_exec"
   "ovrimos_execute"
   "ovrimos_fetch_into"
   "ovrimos_fetch_row"
   "ovrimos_field_len"
   "ovrimos_field_name"
   "ovrimos_field_num"
   "ovrimos_field_type"
   "ovrimos_free_result"
   "ovrimos_longreadlen"
   "ovrimos_num_fields"
   "ovrimos_num_rows"
   "ovrimos_prepare"
   "ovrimos_result"
   "ovrimos_result_all"
   "ovrimos_rollback"
   "pack"
   "getChildren"
   "hasChildren"
   "parse_ini_file"
   "parse_str"
   "parse_url"
   "parsekit_compile_file"
   "parsekit_compile_string"
   "parsekit_func_arginfo"
   "passthru"
   "pathinfo"
   "pclose"
   "pcntl_alarm"
   "pcntl_exec"
   "pcntl_fork"
   "pcntl_getpriority"
   "pcntl_setpriority"
   "pcntl_signal"
   "pcntl_wait"
   "pcntl_waitpid"
   "pcntl_wexitstatus"
   "pcntl_wifexited"
   "pcntl_wifsignaled"
   "pcntl_wifstopped"
   "pcntl_wstopsig"
   "pcntl_wtermsig"
   "pdf_activate_item"
   "pdf_add_annotation"
   "pdf_add_bookmark"
   "pdf_add_launchlink"
   "pdf_add_locallink"
   "pdf_add_nameddest"
   "pdf_add_note"
   "pdf_add_outline"
   "pdf_add_pdflink"
   "pdf_add_table_cell"
   "pdf_add_textflow"
   "pdf_add_thumbnail"
   "pdf_add_weblink"
   "pdf_arc"
   "pdf_arcn"
   "pdf_attach_file"
   "pdf_begin_document"
   "pdf_begin_font"
   "pdf_begin_glyph"
   "pdf_begin_item"
   "pdf_begin_layer"
   "pdf_begin_page"
   "pdf_begin_page_ext"
   "pdf_begin_pattern"
   "pdf_begin_template"
   "pdf_begin_template_ext"
   "pdf_circle"
   "pdf_clip"
   "pdf_close"
   "pdf_close_image"
   "pdf_close_pdi"
   "pdf_close_pdi_page"
   "pdf_closepath"
   "pdf_closepath_fill_stroke"
   "pdf_closepath_stroke"
   "pdf_concat"
   "pdf_continue_text"
   "pdf_create_3dview"
   "pdf_create_action"
   "pdf_create_annotation"
   "pdf_create_bookmark"
   "pdf_create_field"
   "pdf_create_fieldgroup"
   "pdf_create_gstate"
   "pdf_create_pvf"
   "pdf_create_textflow"
   "pdf_curveto"
   "pdf_define_layer"
   "pdf_delete"
   "pdf_delete_pvf"
   "pdf_delete_table"
   "pdf_delete_textflow"
   "pdf_encoding_set_char"
   "pdf_end_document"
   "pdf_end_font"
   "pdf_end_glyph"
   "pdf_end_item"
   "pdf_end_layer"
   "pdf_end_page"
   "pdf_end_page_ext"
   "pdf_end_pattern"
   "pdf_end_template"
   "pdf_endpath"
   "pdf_fill"
   "pdf_fill_imageblock"
   "pdf_fill_pdfblock"
   "pdf_fill_stroke"
   "pdf_fill_textblock"
   "pdf_findfont"
   "pdf_fit_image"
   "pdf_fit_pdi_page"
   "pdf_fit_table"
   "pdf_fit_textflow"
   "pdf_fit_textline"
   "pdf_get_apiname"
   "pdf_get_buffer"
   "pdf_get_errmsg"
   "pdf_get_errnum"
   "pdf_get_font"
   "pdf_get_fontname"
   "pdf_get_fontsize"
   "pdf_get_image_height"
   "pdf_get_image_width"
   "pdf_get_majorversion"
   "pdf_get_minorversion"
   "pdf_get_parameter"
   "pdf_get_pdi_parameter"
   "pdf_get_pdi_value"
   "pdf_get_value"
   "pdf_info_font"
   "pdf_info_matchbox"
   "pdf_info_table"
   "pdf_info_textflow"
   "pdf_info_textline"
   "pdf_initgraphics"
   "pdf_lineto"
   "pdf_load_3ddata"
   "pdf_load_font"
   "pdf_load_iccprofile"
   "pdf_load_image"
   "pdf_makespotcolor"
   "pdf_moveto"
   "pdf_new"
   "pdf_open_ccitt"
   "pdf_open_file"
   "pdf_open_gif"
   "pdf_open_image"
   "pdf_open_image_file"
   "pdf_open_jpeg"
   "pdf_open_memory_image"
   "pdf_open_pdi"
   "pdf_open_pdi_page"
   "pdf_open_tiff"
   "pdf_pcos_get_number"
   "pdf_pcos_get_stream"
   "pdf_pcos_get_string"
   "pdf_place_image"
   "pdf_place_pdi_page"
   "pdf_process_pdi"
   "pdf_rect"
   "pdf_restore"
   "pdf_resume_page"
   "pdf_rotate"
   "pdf_save"
   "pdf_scale"
   "pdf_set_border_color"
   "pdf_set_border_dash"
   "pdf_set_border_style"
   "pdf_set_char_spacing"
   "pdf_set_duration"
   "pdf_set_gstate"
   "pdf_set_horiz_scaling"
   "pdf_set_info"
   "pdf_set_info_author"
   "pdf_set_info_creator"
   "pdf_set_info_keywords"
   "pdf_set_info_subject"
   "pdf_set_info_title"
   "pdf_set_layer_dependency"
   "pdf_set_leading"
   "pdf_set_parameter"
   "pdf_set_text_matrix"
   "pdf_set_text_pos"
   "pdf_set_text_rendering"
   "pdf_set_text_rise"
   "pdf_set_value"
   "pdf_set_word_spacing"
   "pdf_setcolor"
   "pdf_setdash"
   "pdf_setdashpattern"
   "pdf_setflat"
   "pdf_setfont"
   "pdf_setgray"
   "pdf_setgray_fill"
   "pdf_setgray_stroke"
   "pdf_setlinecap"
   "pdf_setlinejoin"
   "pdf_setlinewidth"
   "pdf_setmatrix"
   "pdf_setmiterlimit"
   "pdf_setpolydash"
   "pdf_setrgbcolor"
   "pdf_setrgbcolor_fill"
   "pdf_setrgbcolor_stroke"
   "pdf_shading"
   "pdf_shading_pattern"
   "pdf_shfill"
   "pdf_show"
   "pdf_show_boxed"
   "pdf_show_xy"
   "pdf_skew"
   "pdf_stringwidth"
   "pdf_stroke"
   "pdf_suspend_page"
   "pdf_translate"
   "pdf_utf16_to_utf8"
   "pdf_utf32_to_utf16"
   "pdf_utf8_to_utf16"
   "beginTransaction"
   "errorCode"
   "errorInfo"
   "getAvailableDrivers"
   "lastInsertId"
   "quote"
   "rollBack"
   "sqliteCreateAggregate"
   "sqliteCreateFunction"
   "pgsqlLOBCreate"
   "pgsqlLOBOpen"
   "pgsqlLOBUnlink"
   "bindColumn"
   "bindParam"
   "bindValue"
   "closeCursor"
   "columnCount"
   "execute"
   "fetch"
   "fetchAll"
   "fetchColumn"
   "fetchObject"
   "getColumnMeta"
   "nextRowset"
   "rowCount"
   "setFetchMode"
   "pfsockopen"
   "pg_affected_rows"
   "pg_cancel_query"
   "pg_client_encoding"
   "pg_close"
   "pg_connect"
   "pg_connection_busy"
   "pg_connection_reset"
   "pg_connection_status"
   "pg_convert"
   "pg_copy_from"
   "pg_copy_to"
   "pg_dbname"
   "pg_delete"
   "pg_end_copy"
   "pg_escape_bytea"
   "pg_escape_string"
   "pg_execute"
   "pg_fetch_all"
   "pg_fetch_all_columns"
   "pg_fetch_array"
   "pg_fetch_assoc"
   "pg_fetch_object"
   "pg_fetch_result"
   "pg_fetch_row"
   "pg_field_is_null"
   "pg_field_name"
   "pg_field_num"
   "pg_field_prtlen"
   "pg_field_size"
   "pg_field_table"
   "pg_field_type"
   "pg_field_type_oid"
   "pg_free_result"
   "pg_get_notify"
   "pg_get_pid"
   "pg_get_result"
   "pg_host"
   "pg_insert"
   "pg_last_error"
   "pg_last_notice"
   "pg_last_oid"
   "pg_lo_close"
   "pg_lo_create"
   "pg_lo_export"
   "pg_lo_import"
   "pg_lo_open"
   "pg_lo_read"
   "pg_lo_read_all"
   "pg_lo_seek"
   "pg_lo_tell"
   "pg_lo_unlink"
   "pg_lo_write"
   "pg_meta_data"
   "pg_num_fields"
   "pg_num_rows"
   "pg_options"
   "pg_parameter_status"
   "pg_pconnect"
   "pg_ping"
   "pg_port"
   "pg_prepare"
   "pg_put_line"
   "pg_query"
   "pg_query_params"
   "pg_result_error"
   "pg_result_error_field"
   "pg_result_seek"
   "pg_result_status"
   "pg_select"
   "pg_send_execute"
   "pg_send_prepare"
   "pg_send_query"
   "pg_send_query_params"
   "pg_set_client_encoding"
   "pg_set_error_verbosity"
   "pg_trace"
   "pg_transaction_status"
   "pg_tty"
   "pg_unescape_bytea"
   "pg_untrace"
   "pg_update"
   "pg_version"
   "compressAllFilesBZIP2"
   "compressAllFilesGZ"
   "getMetaData"
   "getModified"
   "getSignature"
   "getStub"
   "isBuffering"
   "setMetaData"
   "setStub"
   "startBuffering"
   "stopBuffering"
   "uncompressAllFiles"
   "apiVersion"
   "canCompress"
   "canWrite"
   "loadPhar"
   "mapPhar"
   "getCompressedSize"
   "getCRC32"
   "getPharFlags"
   "isCompressed"
   "isCompressedBZIP2"
   "isCompressedGZ"
   "isCRCChecked"
   "setCompressedBZIP2"
   "setCompressedGZ"
   "setUncompressed"
   "php_check_syntax"
   "php_ini_scanned_files"
   "php_logo_guid"
   "php_sapi_name"
   "php_strip_whitespace"
   "php_uname"
   "phpcredits"
   "phpinfo"
   "phpversion"
   "pi"
   "png2wbmp"
   "popen"
   "pos"
   "posix_access"
   "posix_ctermid"
   "posix_get_last_error"
   "posix_getcwd"
   "posix_getegid"
   "posix_geteuid"
   "posix_getgid"
   "posix_getgrgid"
   "posix_getgrnam"
   "posix_getgroups"
   "posix_getlogin"
   "posix_getpgid"
   "posix_getpgrp"
   "posix_getpid"
   "posix_getppid"
   "posix_getpwnam"
   "posix_getpwuid"
   "posix_getrlimit"
   "posix_getsid"
   "posix_getuid"
   "posix_initgroups"
   "posix_isatty"
   "posix_kill"
   "posix_mkfifo"
   "posix_mknod"
   "posix_setegid"
   "posix_seteuid"
   "posix_setgid"
   "posix_setpgid"
   "posix_setsid"
   "posix_setuid"
   "posix_strerror"
   "posix_times"
   "posix_ttyname"
   "posix_uname"
   "pow"
   "preg_grep"
   "preg_last_error"
   "preg_match"
   "preg_match_all"
   "preg_quote"
   "preg_replace"
   "preg_replace_callback"
   "preg_split"
   "prev"
   "print"
   "print_r"
   "printer_abort"
   "printer_close"
   "printer_create_brush"
   "printer_create_dc"
   "printer_create_font"
   "printer_create_pen"
   "printer_delete_brush"
   "printer_delete_dc"
   "printer_delete_font"
   "printer_delete_pen"
   "printer_draw_bmp"
   "printer_draw_chord"
   "printer_draw_elipse"
   "printer_draw_line"
   "printer_draw_pie"
   "printer_draw_rectangle"
   "printer_draw_roundrect"
   "printer_draw_text"
   "printer_end_doc"
   "printer_end_page"
   "printer_get_option"
   "printer_list"
   "printer_logical_fontheight"
   "printer_open"
   "printer_select_brush"
   "printer_select_font"
   "printer_select_pen"
   "printer_set_option"
   "printer_start_doc"
   "printer_start_page"
   "printer_write"
   "printf"
   "proc_close"
   "proc_get_status"
   "proc_nice"
   "proc_open"
   "proc_terminate"
   "property_exists"
   "ps_add_bookmark"
   "ps_add_launchlink"
   "ps_add_locallink"
   "ps_add_note"
   "ps_add_pdflink"
   "ps_add_weblink"
   "ps_arc"
   "ps_arcn"
   "ps_begin_page"
   "ps_begin_pattern"
   "ps_begin_template"
   "ps_circle"
   "ps_clip"
   "ps_close"
   "ps_close_image"
   "ps_closepath"
   "ps_closepath_stroke"
   "ps_continue_text"
   "ps_curveto"
   "ps_delete"
   "ps_end_page"
   "ps_end_pattern"
   "ps_end_template"
   "ps_fill"
   "ps_fill_stroke"
   "ps_findfont"
   "ps_get_buffer"
   "ps_get_parameter"
   "ps_get_value"
   "ps_hyphenate"
   "ps_include_file"
   "ps_lineto"
   "ps_makespotcolor"
   "ps_moveto"
   "ps_new"
   "ps_open_file"
   "ps_open_image"
   "ps_open_image_file"
   "ps_open_memory_image"
   "ps_place_image"
   "ps_rect"
   "ps_restore"
   "ps_rotate"
   "ps_save"
   "ps_scale"
   "ps_set_border_color"
   "ps_set_border_dash"
   "ps_set_border_style"
   "ps_set_info"
   "ps_set_parameter"
   "ps_set_text_pos"
   "ps_set_value"
   "ps_setcolor"
   "ps_setdash"
   "ps_setflat"
   "ps_setfont"
   "ps_setgray"
   "ps_setlinecap"
   "ps_setlinejoin"
   "ps_setlinewidth"
   "ps_setmiterlimit"
   "ps_setoverprintmode"
   "ps_setpolydash"
   "ps_shading"
   "ps_shading_pattern"
   "ps_shfill"
   "ps_show"
   "ps_show2"
   "ps_show_boxed"
   "ps_show_xy"
   "ps_show_xy2"
   "ps_string_geometry"
   "ps_stringwidth"
   "ps_stroke"
   "ps_symbol"
   "ps_symbol_name"
   "ps_symbol_width"
   "ps_translate"
   "pspell_add_to_personal"
   "pspell_add_to_session"
   "pspell_check"
   "pspell_clear_session"
   "pspell_config_create"
   "pspell_config_data_dir"
   "pspell_config_dict_dir"
   "pspell_config_ignore"
   "pspell_config_mode"
   "pspell_config_personal"
   "pspell_config_repl"
   "pspell_config_runtogether"
   "pspell_config_save_repl"
   "pspell_new"
   "pspell_new_config"
   "pspell_new_personal"
   "pspell_save_wordlist"
   "pspell_store_replacement"
   "pspell_suggest"
   "putenv"
   "px_close"
   "px_create_fp"
   "px_date2string"
   "px_delete"
   "px_delete_record"
   "px_get_field"
   "px_get_info"
   "px_get_parameter"
   "px_get_record"
   "px_get_schema"
   "px_get_value"
   "px_insert_record"
   "px_new"
   "px_numfields"
   "px_numrecords"
   "px_open_fp"
   "px_put_record"
   "px_retrieve_record"
   "px_set_blob_file"
   "px_set_parameter"
   "px_set_tablename"
   "px_set_targetencoding"
   "px_set_value"
   "px_timestamp2string"
   "px_update_record"
   "qdom_error"
   "qdom_tree"
   "quoted_printable_decode"
   "quotemeta"
   "rad2deg"
   "radius_acct_open"
   "radius_add_server"
   "radius_auth_open"
   "radius_close"
   "radius_config"
   "radius_create_request"
   "radius_cvt_addr"
   "radius_cvt_int"
   "radius_cvt_string"
   "radius_demangle"
   "radius_demangle_mppe_key"
   "radius_get_attr"
   "radius_get_vendor_attr"
   "radius_put_addr"
   "radius_put_attr"
   "radius_put_int"
   "radius_put_string"
   "radius_put_vendor_addr"
   "radius_put_vendor_attr"
   "radius_put_vendor_int"
   "radius_put_vendor_string"
   "radius_request_authenticator"
   "radius_send_request"
   "radius_server_secret"
   "radius_strerror"
   "rand"
   "range"
   "getAttr"
   "getCrc"
   "getFileTime"
   "getHostOs"
   "getName"
   "getPackedSize"
   "getUnpackedSize"
   "rar_close"
   "rar_entry_get"
   "rar_list"
   "rar_open"
   "rawurldecode"
   "rawurlencode"
   "read_exif_data"
   "readdir"
   "readfile"
   "readgzfile"
   "readline"
   "readline_add_history"
   "readline_callback_handler_install"
   "readline_callback_handler_remove"
   "readline_callback_read_char"
   "readline_clear_history"
   "readline_completion_function"
   "readline_info"
   "readline_list_history"
   "readline_on_new_line"
   "readline_read_history"
   "readline_redisplay"
   "readline_write_history"
   "readlink"
   "realpath"
   "recode"
   "recode_file"
   "recode_string"
   "getDepth"
   "getSubIterator"
   "register_shutdown_function"
   "register_tick_function"
   "rename"
   "rename_function"
   "restore_error_handler"
   "restore_exception_handler"
   "restore_include_path"
   "current_field"
   "data_seek"
   "fetch_array"
   "fetch_field"
   "fetch_field_direct"
   "fetch_fields"
   "fetch_object"
   "fetch_row"
   "field_seek"
   "lengths"
   "rewinddir"
   "rmdir"
   "round"
   "rpm_close"
   "rpm_get_tag"
   "rpm_is_valid"
   "rpm_open"
   "rpm_version"
   "rsort"
   "rtrim"
   "runkit_class_adopt"
   "runkit_class_emancipate"
   "runkit_constant_add"
   "runkit_constant_redefine"
   "runkit_constant_remove"
   "runkit_function_add"
   "runkit_function_copy"
   "runkit_function_redefine"
   "runkit_function_remove"
   "runkit_function_rename"
   "runkit_import"
   "runkit_lint"
   "runkit_lint_file"
   "runkit_method_add"
   "runkit_method_copy"
   "runkit_method_redefine"
   "runkit_method_remove"
   "runkit_method_rename"
   "runkit_return_value_used"
   "runkit_sandbox"
   "runkit_sandbox_output_handler"
   "runkit_sandbox_parent"
   "runkit_superglobals"
   "disconnect"
   "isConnected"
   "peek"
   "peekAll"
   "receive"
   "subscribe"
   "unsubscribe"
   "setDebug"
   "body"
   "createDataObject"
   "getService"
   "scandir"
   "beginLogging"
   "endLogging"
   "getChangedDataObjects"
   "getChangeType"
   "getOldContainer"
   "getOldValues"
   "isLogging"
   "addPropertyToType"
   "addType"
   "getDataFactory"
   "getChangeSummary"
   "applyChanges"
   "createRootDataObject"
   "executePreparedQuery"
   "executeQuery"
   "getListIndex"
   "getPropertyIndex"
   "getPropertyName"
   "getValue"
   "isSet"
   "addTypes"
   "create"
   "loadFile"
   "loadString"
   "saveString"
   "getRootDataObject"
   "getRootElementName"
   "getRootElementURI"
   "setEncoding"
   "setXMLDeclaration"
   "setXMLVersion"
   "getContainer"
   "getSequence"
   "getTypeName"
   "getTypeNamespaceURI"
   "getCause"
   "getContainingType"
   "getDefault"
   "isContainment"
   "isMany"
   "getContainmentProperty"
   "getInstanceProperties"
   "getBaseType"
   "getNamespaceURI"
   "getProperties"
   "getProperty"
   "isAbstractType"
   "isDataType"
   "isInstance"
   "isOpenType"
   "isSequencedType"
   "sem_acquire"
   "sem_get"
   "sem_release"
   "sem_remove"
   "serialize"
   "session_cache_expire"
   "session_cache_limiter"
   "session_commit"
   "session_decode"
   "session_destroy"
   "session_encode"
   "session_get_cookie_params"
   "session_id"
   "session_is_registered"
   "session_module_name"
   "session_name"
   "session_pgsql_add_error"
   "session_pgsql_get_error"
   "session_pgsql_get_field"
   "session_pgsql_reset"
   "session_pgsql_set_field"
   "session_pgsql_status"
   "session_regenerate_id"
   "session_register"
   "session_save_path"
   "session_set_cookie_params"
   "session_set_save_handler"
   "session_start"
   "session_unregister"
   "session_unset"
   "session_write_close"
   "set_error_handler"
   "set_exception_handler"
   "set_file_buffer"
   "set_include_path"
   "set_magic_quotes_runtime"
   "set_time_limit"
   "setcookie"
   "setlocale"
   "setrawcookie"
   "settype"
   "sha1"
   "sha1_file"
   "shell_exec"
   "shm_attach"
   "shm_detach"
   "shm_get_var"
   "shm_put_var"
   "shm_remove"
   "shm_remove_var"
   "shmop_close"
   "shmop_delete"
   "shmop_open"
   "shmop_read"
   "shmop_size"
   "shmop_write"
   "show_source"
   "shuffle"
   "similar_text"
   "simplexml_import_dom"
   "simplexml_load_file"
   "simplexml_load_string"
   "addAttribute"
   "addChild"
   "asXML"
   "getDocNamespaces"
   "getNamespaces"
   "registerXPathNamespace"
   "xpath"
   "sin"
   "sinh"
   "sizeof"
   "sleep"
   "snmp_get_quick_print"
   "snmp_get_valueretrieval"
   "snmp_read_mib"
   "snmp_set_enum_print"
   "snmp_set_oid_numeric_print"
   "snmp_set_oid_output_format"
   "snmp_set_quick_print"
   "snmp_set_valueretrieval"
   "snmpget"
   "snmpgetnext"
   "snmprealwalk"
   "snmpset"
   "snmpwalk"
   "snmpwalkoid"
   "__call"
   "__doRequest"
   "__getFunctions"
   "__getLastRequest"
   "__getLastRequestHeaders"
   "__getLastResponse"
   "__getLastResponseHeaders"
   "__getTypes"
   "__setCookie"
   "__soapCall"
   "addFunction"
   "fault"
   "getFunctions"
   "handle"
   "setClass"
   "setPersistence"
   "socket_accept"
   "socket_bind"
   "socket_clear_error"
   "socket_close"
   "socket_connect"
   "socket_create"
   "socket_create_listen"
   "socket_create_pair"
   "socket_get_option"
   "socket_get_status"
   "socket_getpeername"
   "socket_getsockname"
   "socket_last_error"
   "socket_listen"
   "socket_read"
   "socket_recv"
   "socket_recvfrom"
   "socket_select"
   "socket_send"
   "socket_sendto"
   "socket_set_block"
   "socket_set_blocking"
   "socket_set_nonblock"
   "socket_set_option"
   "socket_set_timeout"
   "socket_shutdown"
   "socket_strerror"
   "socket_write"
   "sort"
   "soundex"
   "spl_autoload"
   "spl_autoload_call"
   "spl_autoload_extensions"
   "spl_autoload_functions"
   "spl_autoload_register"
   "spl_autoload_unregister"
   "spl_classes"
   "spl_object_hash"
   "split"
   "spliti"
   "sprintf"
   "sql_regcase"
   "sqlite_array_query"
   "sqlite_busy_timeout"
   "sqlite_changes"
   "sqlite_close"
   "sqlite_column"
   "sqlite_create_aggregate"
   "sqlite_create_function"
   "sqlite_current"
   "sqlite_error_string"
   "sqlite_escape_string"
   "sqlite_exec"
   "sqlite_factory"
   "sqlite_fetch_all"
   "sqlite_fetch_array"
   "sqlite_fetch_column_types"
   "sqlite_fetch_object"
   "sqlite_fetch_single"
   "sqlite_fetch_string"
   "sqlite_field_name"
   "sqlite_has_more"
   "sqlite_has_prev"
   "sqlite_key"
   "sqlite_last_error"
   "sqlite_last_insert_rowid"
   "sqlite_libencoding"
   "sqlite_libversion"
   "sqlite_next"
   "sqlite_num_fields"
   "sqlite_num_rows"
   "sqlite_open"
   "sqlite_popen"
   "sqlite_prev"
   "sqlite_query"
   "sqlite_rewind"
   "sqlite_seek"
   "sqlite_single_query"
   "sqlite_udf_decode_binary"
   "sqlite_udf_encode_binary"
   "sqlite_unbuffered_query"
   "sqlite_valid"
   "arrayQuery"
   "busyTimeout"
   "changes"
   "createAggregate"
   "createFunction"
   "fetchColumnTypes"
   "lastError"
   "lastInsertRowid"
   "singleQuery"
   "unbufferedQuery"
   "column"
   "fetchSingle"
   "fieldName"
   "hasPrev"
   "numFields"
   "sqrt"
   "srand"
   "sscanf"
   "ssh2_auth_hostbased_file"
   "ssh2_auth_none"
   "ssh2_auth_password"
   "ssh2_auth_pubkey_file"
   "ssh2_connect"
   "ssh2_exec"
   "ssh2_fetch_stream"
   "ssh2_fingerprint"
   "ssh2_methods_negotiated"
   "ssh2_publickey_add"
   "ssh2_publickey_init"
   "ssh2_publickey_list"
   "ssh2_publickey_remove"
   "ssh2_scp_recv"
   "ssh2_scp_send"
   "ssh2_sftp"
   "ssh2_sftp_lstat"
   "ssh2_sftp_mkdir"
   "ssh2_sftp_readlink"
   "ssh2_sftp_realpath"
   "ssh2_sftp_rename"
   "ssh2_sftp_rmdir"
   "ssh2_sftp_stat"
   "ssh2_sftp_symlink"
   "ssh2_sftp_unlink"
   "ssh2_shell"
   "ssh2_tunnel"
   "stats_absolute_deviation"
   "stats_cdf_beta"
   "stats_cdf_binomial"
   "stats_cdf_cauchy"
   "stats_cdf_chisquare"
   "stats_cdf_exponential"
   "stats_cdf_f"
   "stats_cdf_gamma"
   "stats_cdf_laplace"
   "stats_cdf_logistic"
   "stats_cdf_negative_binomial"
   "stats_cdf_noncentral_chisquare"
   "stats_cdf_noncentral_f"
   "stats_cdf_poisson"
   "stats_cdf_t"
   "stats_cdf_uniform"
   "stats_cdf_weibull"
   "stats_covariance"
   "stats_den_uniform"
   "stats_dens_beta"
   "stats_dens_cauchy"
   "stats_dens_chisquare"
   "stats_dens_exponential"
   "stats_dens_f"
   "stats_dens_gamma"
   "stats_dens_laplace"
   "stats_dens_logistic"
   "stats_dens_negative_binomial"
   "stats_dens_normal"
   "stats_dens_pmf_binomial"
   "stats_dens_pmf_hypergeometric"
   "stats_dens_pmf_poisson"
   "stats_dens_t"
   "stats_dens_weibull"
   "stats_harmonic_mean"
   "stats_kurtosis"
   "stats_rand_gen_beta"
   "stats_rand_gen_chisquare"
   "stats_rand_gen_exponential"
   "stats_rand_gen_f"
   "stats_rand_gen_funiform"
   "stats_rand_gen_gamma"
   "stats_rand_gen_ibinomial"
   "stats_rand_gen_ibinomial_negative"
   "stats_rand_gen_int"
   "stats_rand_gen_ipoisson"
   "stats_rand_gen_iuniform"
   "stats_rand_gen_noncenral_chisquare"
   "stats_rand_gen_noncentral_f"
   "stats_rand_gen_noncentral_t"
   "stats_rand_gen_normal"
   "stats_rand_gen_t"
   "stats_rand_get_seeds"
   "stats_rand_phrase_to_seeds"
   "stats_rand_ranf"
   "stats_rand_setall"
   "stats_skew"
   "stats_standard_deviation"
   "stats_stat_binomial_coef"
   "stats_stat_correlation"
   "stats_stat_gennch"
   "stats_stat_independent_t"
   "stats_stat_innerproduct"
   "stats_stat_noncentral_t"
   "stats_stat_paired_t"
   "stats_stat_percentile"
   "stats_stat_powersum"
   "stats_variance"
   "bind_param"
   "bind_result"
   "free_result"
   "num_rows"
   "param_count"
   "send_long_data"
   "str_getcsv"
   "str_ireplace"
   "str_pad"
   "str_repeat"
   "str_replace"
   "str_rot13"
   "str_shuffle"
   "str_split"
   "str_word_count"
   "strcasecmp"
   "strchr"
   "strcmp"
   "strcoll"
   "strcspn"
   "stream_bucket_append"
   "stream_bucket_make_writeable"
   "stream_bucket_new"
   "stream_bucket_prepend"
   "stream_context_create"
   "stream_context_get_default"
   "stream_context_get_options"
   "stream_context_set_option"
   "stream_context_set_params"
   "stream_copy_to_stream"
   "stream_encoding"
   "stream_filter_append"
   "stream_filter_prepend"
   "stream_filter_register"
   "stream_filter_remove"
   "stream_get_contents"
   "stream_get_filters"
   "stream_get_line"
   "stream_get_meta_data"
   "stream_get_transports"
   "stream_get_wrappers"
   "stream_register_wrapper"
   "stream_resolve_include_path"
   "stream_select"
   "stream_set_blocking"
   "stream_set_timeout"
   "stream_set_write_buffer"
   "stream_socket_accept"
   "stream_socket_client"
   "stream_socket_enable_crypto"
   "stream_socket_get_name"
   "stream_socket_pair"
   "stream_socket_recvfrom"
   "stream_socket_sendto"
   "stream_socket_server"
   "stream_socket_shutdown"
   "stream_wrapper_register"
   "stream_wrapper_restore"
   "stream_wrapper_unregister"
   "strftime"
   "strip_tags"
   "stripcslashes"
   "stripos"
   "stripslashes"
   "stristr"
   "strlen"
   "strnatcasecmp"
   "strnatcmp"
   "strncasecmp"
   "strncmp"
   "strpbrk"
   "strpos"
   "strptime"
   "strrchr"
   "strrev"
   "strripos"
   "strrpos"
   "strspn"
   "strstr"
   "strtok"
   "strtolower"
   "strtotime"
   "strtoupper"
   "strtr"
   "strval"
   "substr"
   "substr_compare"
   "substr_count"
   "substr_replace"
   "svn_add"
   "svn_auth_get_parameter"
   "svn_auth_set_parameter"
   "svn_cat"
   "svn_checkout"
   "svn_cleanup"
   "svn_client_version"
   "svn_commit"
   "svn_diff"
   "svn_fs_abort_txn"
   "svn_fs_apply_text"
   "svn_fs_begin_txn2"
   "svn_fs_change_node_prop"
   "svn_fs_check_path"
   "svn_fs_contents_changed"
   "svn_fs_copy"
   "svn_fs_delete"
   "svn_fs_dir_entries"
   "svn_fs_file_contents"
   "svn_fs_file_length"
   "svn_fs_is_dir"
   "svn_fs_is_file"
   "svn_fs_make_dir"
   "svn_fs_make_file"
   "svn_fs_node_created_rev"
   "svn_fs_node_prop"
   "svn_fs_props_changed"
   "svn_fs_revision_prop"
   "svn_fs_revision_root"
   "svn_fs_txn_root"
   "svn_fs_youngest_rev"
   "svn_import"
   "svn_log"
   "svn_ls"
   "svn_repos_create"
   "svn_repos_fs"
   "svn_repos_fs_begin_txn_for_commit"
   "svn_repos_fs_commit_txn"
   "svn_repos_hotcopy"
   "svn_repos_open"
   "svn_repos_recover"
   "svn_status"
   "svn_update"
   "swf_actiongeturl"
   "swf_actiongotoframe"
   "swf_actiongotolabel"
   "swf_actionnextframe"
   "swf_actionplay"
   "swf_actionprevframe"
   "swf_actionsettarget"
   "swf_actionstop"
   "swf_actiontogglequality"
   "swf_actionwaitforframe"
   "swf_addbuttonrecord"
   "swf_addcolor"
   "swf_closefile"
   "swf_definebitmap"
   "swf_definefont"
   "swf_defineline"
   "swf_definepoly"
   "swf_definerect"
   "swf_definetext"
   "swf_endbutton"
   "swf_enddoaction"
   "swf_endshape"
   "swf_endsymbol"
   "swf_fontsize"
   "swf_fontslant"
   "swf_fonttracking"
   "swf_getbitmapinfo"
   "swf_getfontinfo"
   "swf_getframe"
   "swf_labelframe"
   "swf_lookat"
   "swf_modifyobject"
   "swf_mulcolor"
   "swf_nextid"
   "swf_oncondition"
   "swf_openfile"
   "swf_ortho"
   "swf_ortho2"
   "swf_perspective"
   "swf_placeobject"
   "swf_polarview"
   "swf_popmatrix"
   "swf_posround"
   "swf_pushmatrix"
   "swf_removeobject"
   "swf_rotate"
   "swf_scale"
   "swf_setfont"
   "swf_setframe"
   "swf_shapearc"
   "swf_shapecurveto"
   "swf_shapecurveto3"
   "swf_shapefillbitmapclip"
   "swf_shapefillbitmaptile"
   "swf_shapefilloff"
   "swf_shapefillsolid"
   "swf_shapelinesolid"
   "swf_shapelineto"
   "swf_shapemoveto"
   "swf_showframe"
   "swf_startbutton"
   "swf_startdoaction"
   "swf_startshape"
   "swf_startsymbol"
   "swf_textwidth"
   "swf_translate"
   "swf_viewport"
   "addAction"
   "addASound"
   "addShape"
   "setAction"
   "setDown"
   "setHit"
   "setMenu"
   "setOver"
   "setUp"
   "addColor"
   "endMask"
   "getRot"
   "getX"
   "getXScale"
   "getXSkew"
   "getY"
   "getYScale"
   "getYSkew"
   "multColor"
   "rotateTo"
   "scaleTo"
   "setDepth"
   "setMaskLevel"
   "setMatrix"
   "setName"
   "setRatio"
   "skewXTo"
   "skewYTo"
   "getLeading"
   "getShape"
   "getUTF8Width"
   "addChars"
   "addUTF8Chars"
   "addEntry"
   "getShape1"
   "getShape2"
   "addExport"
   "addFont"
   "importChar"
   "importFont"
   "labelFrame"
   "nextFrame"
   "saveToFile"
   "setbackground"
   "setDimension"
   "setFrames"
   "setRate"
   "startSound"
   "stopSound"
   "streamMP3"
   "writeExports"
   "addFill"
   "drawArc"
   "drawCircle"
   "drawCubic"
   "drawCubicTo"
   "drawCurve"
   "drawCurveTo"
   "drawGlyph"
   "drawLine"
   "drawLineTo"
   "movePen"
   "movePenTo"
   "setLeftFill"
   "setLine"
   "setRightFill"
   "swfsound"
   "loopCount"
   "loopInPoint"
   "loopOutPoint"
   "noMultiple"
   "addString"
   "addUTF8String"
   "setSpacing"
   "align"
   "setBounds"
   "setIndentation"
   "setLeftMargin"
   "setLineSpacing"
   "setMargins"
   "setPadding"
   "setRightMargin"
   "getNumFrames"
   "getMetaList"
   "getPropertyList"
   "stem"
   "getParsedWords"
   "getRemovedStopwords"
   "nextResult"
   "seekResult"
   "resetLimit"
   "setLimit"
   "setPhraseDelimiter"
   "setSort"
   "setStructure"
   "sybase_affected_rows"
   "sybase_close"
   "sybase_connect"
   "sybase_data_seek"
   "sybase_deadlock_retry_count"
   "sybase_fetch_array"
   "sybase_fetch_assoc"
   "sybase_fetch_field"
   "sybase_fetch_object"
   "sybase_fetch_row"
   "sybase_field_seek"
   "sybase_free_result"
   "sybase_get_last_message"
   "sybase_min_client_severity"
   "sybase_min_error_severity"
   "sybase_min_message_severity"
   "sybase_min_server_severity"
   "sybase_num_fields"
   "sybase_num_rows"
   "sybase_pconnect"
   "sybase_query"
   "sybase_result"
   "sybase_select_db"
   "sybase_set_message_handler"
   "sybase_unbuffered_query"
   "symlink"
   "sys_get_temp_dir"
   "sys_getloadavg"
   "syslog"
   "system"
   "tan"
   "tanh"
   "tcpwrap_check"
   "tempnam"
   "textdomain"
   "tidy_access_count"
   "tidy_clean_repair"
   "tidy_config_count"
   "tidy_diagnose"
   "tidy_error_count"
   "tidy_get_body"
   "tidy_get_config"
   "tidy_get_error_buffer"
   "tidy_get_head"
   "tidy_get_html"
   "tidy_get_html_ver"
   "tidy_get_opt_doc"
   "tidy_get_output"
   "tidy_get_release"
   "tidy_get_root"
   "tidy_get_status"
   "tidy_getopt"
   "tidy_is_xhtml"
   "tidy_is_xml"
   "tidy_load_config"
   "get_attr"
   "get_nodes"
   "tidy_parse_file"
   "tidy_parse_string"
   "tidy_repair_file"
   "tidy_repair_string"
   "tidy_reset_config"
   "tidy_save_config"
   "tidy_set_encoding"
   "tidy_setopt"
   "tidy_warning_count"
   "hasSiblings"
   "isAsp"
   "isComment"
   "isHtml"
   "isJste"
   "isPhp"
   "isText"
   "getParent"
   "time"
   "time_nanosleep"
   "time_sleep_until"
   "timezone_abbreviations_list"
   "timezone_identifiers_list"
   "timezone_name_from_abbr"
   "timezone_name_get"
   "timezone_offset_get"
   "timezone_open"
   "timezone_transitions_get"
   "tmpfile"
   "token_get_all"
   "token_name"
   "touch"
   "trigger_error"
   "uasort"
   "ucfirst"
   "ucwords"
   "udm_add_search_limit"
   "udm_alloc_agent"
   "udm_alloc_agent_array"
   "udm_api_version"
   "udm_cat_list"
   "udm_cat_path"
   "udm_check_charset"
   "udm_check_stored"
   "udm_clear_search_limits"
   "udm_close_stored"
   "udm_crc32"
   "udm_errno"
   "udm_error"
   "udm_find"
   "udm_free_agent"
   "udm_free_ispell_data"
   "udm_free_res"
   "udm_get_doc_count"
   "udm_get_res_field"
   "udm_get_res_param"
   "udm_hash32"
   "udm_load_ispell_data"
   "udm_open_stored"
   "udm_set_agent_param"
   "uksort"
   "umask"
   "unicode_decode"
   "unicode_encode"
   "unicode_get_error_mode"
   "unicode_get_subst_char"
   "unicode_set_error_mode"
   "unicode_set_subst_char"
   "uniqid"
   "unixtojd"
   "unlink"
   "unpack"
   "unregister_tick_function"
   "unserialize"
   "unset"
   "urldecode"
   "urlencode"
   "use_soap_error_handler"
   "user_error"
   "usleep"
   "usort"
   "utf8_decode"
   "utf8_encode"
   "var_dump"
   "var_export"
   "variant"
   "variant_abs"
   "variant_add"
   "variant_and"
   "variant_cast"
   "variant_cat"
   "variant_cmp"
   "variant_date_from_timestamp"
   "variant_date_to_timestamp"
   "variant_div"
   "variant_eqv"
   "variant_fix"
   "variant_get_type"
   "variant_idiv"
   "variant_imp"
   "variant_int"
   "variant_mod"
   "variant_mul"
   "variant_neg"
   "variant_not"
   "variant_or"
   "variant_pow"
   "variant_round"
   "variant_set"
   "variant_set_type"
   "variant_sub"
   "variant_xor"
   "version_compare"
   "vfprintf"
   "virtual"
   "vpopmail_add_alias_domain"
   "vpopmail_add_alias_domain_ex"
   "vpopmail_add_domain"
   "vpopmail_add_domain_ex"
   "vpopmail_add_user"
   "vpopmail_alias_add"
   "vpopmail_alias_del"
   "vpopmail_alias_del_domain"
   "vpopmail_alias_get"
   "vpopmail_alias_get_all"
   "vpopmail_auth_user"
   "vpopmail_del_domain"
   "vpopmail_del_domain_ex"
   "vpopmail_del_user"
   "vpopmail_error"
   "vpopmail_passwd"
   "vpopmail_set_user_quota"
   "vprintf"
   "vsprintf"
   "w32api_deftype"
   "w32api_init_dtype"
   "w32api_invoke_function"
   "w32api_register_function"
   "w32api_set_call_method"
   "wddx_add_vars"
   "wddx_deserialize"
   "wddx_packet_end"
   "wddx_packet_start"
   "wddx_serialize_value"
   "wddx_serialize_vars"
   "wddx_unserialize"
   "win32_create_service"
   "win32_delete_service"
   "win32_get_last_control_message"
   "win32_ps_list_procs"
   "win32_ps_stat_mem"
   "win32_ps_stat_proc"
   "win32_query_service_status"
   "win32_set_service_status"
   "win32_start_service"
   "win32_start_service_ctrl_dispatcher"
   "win32_stop_service"
   "wordwrap"
   "xattr_get"
   "xattr_list"
   "xattr_remove"
   "xattr_set"
   "xattr_supported"
   "xdiff_file_diff"
   "xdiff_file_diff_binary"
   "xdiff_file_merge3"
   "xdiff_file_patch"
   "xdiff_file_patch_binary"
   "xdiff_string_diff"
   "xdiff_string_diff_binary"
   "xdiff_string_merge3"
   "xdiff_string_patch"
   "xdiff_string_patch_binary"
   "xml_error_string"
   "xml_get_current_byte_index"
   "xml_get_current_column_number"
   "xml_get_current_line_number"
   "xml_get_error_code"
   "xml_parse"
   "xml_parse_into_struct"
   "xml_parser_create"
   "xml_parser_create_ns"
   "xml_parser_free"
   "xml_parser_get_option"
   "xml_parser_set_option"
   "xml_set_character_data_handler"
   "xml_set_default_handler"
   "xml_set_element_handler"
   "xml_set_end_namespace_decl_handler"
   "xml_set_external_entity_ref_handler"
   "xml_set_notation_decl_handler"
   "xml_set_object"
   "xml_set_processing_instruction_handler"
   "xml_set_start_namespace_decl_handler"
   "xml_set_unparsed_entity_decl_handler"
   "expand"
   "getAttributeNo"
   "getAttributeNs"
   "getParserProperty"
   "isValid"
   "lookupNamespace"
   "moveToAttribute"
   "moveToAttributeNo"
   "moveToAttributeNs"
   "moveToElement"
   "moveToFirstAttribute"
   "moveToNextAttribute"
   "open"
   "setParserProperty"
   "setRelaxNGSchema"
   "setRelaxNGSchemaSource"
   "XML"
   "xmlrpc_decode"
   "xmlrpc_decode_request"
   "xmlrpc_encode"
   "xmlrpc_encode_request"
   "xmlrpc_get_type"
   "xmlrpc_is_fault"
   "xmlrpc_parse_method_descriptions"
   "xmlrpc_server_add_introspection_data"
   "xmlrpc_server_call_method"
   "xmlrpc_server_create"
   "xmlrpc_server_destroy"
   "xmlrpc_server_register_introspection_callback"
   "xmlrpc_server_register_method"
   "xmlrpc_set_type"
   "endAttribute"
   "endCData"
   "endComment"
   "endDocument"
   "endDTD"
   "endDTDAttlist"
   "endDTDElement"
   "endDTDEntity"
   "endElement"
   "endPI"
   "fullEndElement"
   "openMemory"
   "openURI"
   "outputMemory"
   "setIndent"
   "setIndentString"
   "startAttribute"
   "startAttributeNS"
   "startCData"
   "startComment"
   "startDocument"
   "startDTD"
   "startDTDAttlist"
   "startDTDElement"
   "startDTDEntity"
   "startElement"
   "startElementNS"
   "startPI"
   "text"
   "writeAttribute"
   "writeAttributeNS"
   "writeCData"
   "writeComment"
   "writeDTD"
   "writeDTDAttlist"
   "writeDTDElement"
   "writeDTDEntity"
   "writeElement"
   "writeElementNS"
   "writePI"
   "writeRaw"
   "xpath_eval"
   "xpath_eval_expression"
   "xpath_new_context"
   "xpath_register_ns"
   "xpath_register_ns_auto"
   "xptr_eval"
   "xptr_new_context"
   "xslt_backend_info"
   "xslt_backend_name"
   "xslt_backend_version"
   "xslt_create"
   "xslt_errno"
   "xslt_error"
   "xslt_free"
   "xslt_getopt"
   "xslt_process"
   "xslt_set_base"
   "xslt_set_encoding"
   "xslt_set_error_handler"
   "xslt_set_log"
   "xslt_set_object"
   "xslt_set_sax_handler"
   "xslt_set_sax_handlers"
   "xslt_set_scheme_handler"
   "xslt_set_scheme_handlers"
   "xslt_setopt"
   "getParameter"
   "hasExsltSupport"
   "importStylesheet"
   "registerPHPFunctions"
   "removeParameter"
   "setParameter"
   "transformToDoc"
   "transformToURI"
   "transformToXML"
   "yaz_addinfo"
   "yaz_ccl_conf"
   "yaz_ccl_parse"
   "yaz_close"
   "yaz_connect"
   "yaz_database"
   "yaz_element"
   "yaz_errno"
   "yaz_error"
   "yaz_es"
   "yaz_es_result"
   "yaz_get_option"
   "yaz_hits"
   "yaz_itemorder"
   "yaz_present"
   "yaz_range"
   "yaz_record"
   "yaz_scan"
   "yaz_scan_result"
   "yaz_schema"
   "yaz_search"
   "yaz_set_option"
   "yaz_sort"
   "yaz_syntax"
   "yaz_wait"
   "yp_all"
   "yp_cat"
   "yp_err_string"
   "yp_errno"
   "yp_first"
   "yp_get_default_domain"
   "yp_master"
   "yp_match"
   "yp_next"
   "yp_order"
   "zend_logo_guid"
   "zend_thread_id"
   "zend_version"
   "zip_close"
   "zip_entry_close"
   "zip_entry_compressedsize"
   "zip_entry_compressionmethod"
   "zip_entry_filesize"
   "zip_entry_name"
   "zip_entry_open"
   "zip_entry_read"
   "zip_open"
   "zip_read"
   "addEmptyDir"
   "addFile"
   "addFromString"
   "deleteIndex"
   "deleteName"
   "extractTo"
   "getArchiveComment"
   "getCommentIndex"
   "getCommentName"
   "getFromIndex"
   "getFromName"
   "getNameIndex"
   "locateName"
   "renameIndex"
   "renameName"
   "setArchiveComment"
   "setCommentIndex"
   "setCommentName"
   "statIndex"
   "statName"
   "unchangeAll"
   "unchangeArchive"
   "unchangeIndex"
   "unchangeName"
   "zlib_get_coding_type"
   ))

(phpcmp-db-update
 'ini-directives
 '(
   "allow_call_time_pass_reference"
   "allow_url_fopen"
   "allow_url_include"
   "always_populate_raw_post_data"
   "apc.cache_by_default"
   "apc.enabled"
   "apc.enable_cli"
   "apc.file_update_protection"
   "apc.filters"
   "apc.gc_ttl"
   "apc.include_once_override"
   "apc.localcache"
   "apc.localcache.size"
   "apc.max_file_size"
   "apc.mmap_file_mask"
   "apc.num_files_hint"
   "apc.optimization"
   "apc.report_autofilter"
   "apc.rfc1867"
   "apc.rfc1867_freq"
   "apc.rfc1867_name"
   "apc.rfc1867_prefix"
   "apc.shm_segments"
   "apc.shm_size"
   "apc.slam_defense"
   "apc.stat"
   "apc.stat_ctime"
   "apc.ttl"
   "apc.user_entries_hint"
   "apc.user_ttl"
   "apc.write_lock"
   "apd.bitmask"
   "apd.dumpdir"
   "apd.statement_tracing"
   "arg_separator"
   "arg_separator.input"
   "arg_separator.output"
   "asp_tags"
   "assert.active"
   "assert.bail"
   "assert.callback"
   "assert.quiet_eval"
   "assert.warning"
   "auto_append_file"
   "auto_detect_line_endings"
   "auto_globals_jit"
   "auto_prepend_file"
   "axis2.client_home"
   "axis2.enable_exception"
   "axis2.enable_trace"
   "axis2.log_path"
   "bcmath.scale"
   "bcompiler.enabled"
   "birdstep.max_links"
   "blenc.key_file"
   "browscap"
   "cgi.check_shebang_line"
   "cgi.discard_path"
   "cgi.fix_pathinfo"
   "cgi.force_redirect"
   "cgi.nph"
   "cgi.redirect_status_env"
   "cgi.rfc2616_headers"
   "child_terminate"
   "coin_acceptor.autoreset"
   "coin_acceptor.auto_initialize"
   "coin_acceptor.auto_reset"
   "coin_acceptor.command_function"
   "coin_acceptor.delay"
   "coin_acceptor.delay_coins"
   "coin_acceptor.delay_prom"
   "coin_acceptor.device"
   "coin_acceptor.lock_on_close"
   "coin_acceptor.start_unlocked"
   "com.allow_dcom"
   "com.autoregister_casesensitive"
   "com.autoregister_typelib"
   "com.autoregister_verbose"
   "com.code_page"
   "com.typelib_file"
   "crack.default_dictionary"
   "daffodildb.default_host"
   "daffodildb.default_password"
   "daffodildb.default_socket"
   "daffodildb.default_user"
   "daffodildb.port"
   "date.default_latitude"
   "date.default_longitude"
   "date.sunrise_zenith"
   "date.sunset_zenith"
   "date.timezone"
   "dba.default_handler"
   "dbx.colnames_case"
   "default_charset"
   "default_mimetype"
   "default_socket_timeout"
   "define_syslog_variables"
   "detect_unicode"
   "disable_classes"
   "disable_functions"
   "display_errors"
   "display_startup_errors"
   "docref_ext"
   "docref_root"
   "doc_root"
   "enable_dl"
   "engine"
   "error_append_string"
   "error_log"
   "error_prepend_string"
   "error_reporting"
   "etpan.default.charset"
   "etpan.default.protocol"
   "exif.decode_jis_intel"
   "exif.decode_jis_motorola"
   "exif.decode_unicode_intel"
   "exif.decode_unicode_motorola"
   "exif.encode_jis"
   "exif.encode_unicode"
   "expect.logfile"
   "expect.loguser"
   "expect.timeout"
   "expose_php"
   "extension_dir"
   "fastcgi.impersonate"
   "fastcgi.logging"
   "fbsql.allow_persistant"
   "fbsql.allow_persistent"
   "fbsql.autocommit"
   "fbsql.batchSize"
   "fbsql.batchsize"
   "fbsql.default_database"
   "fbsql.default_database_password"
   "fbsql.default_host"
   "fbsql.default_password"
   "fbsql.default_user"
   "fbsql.generate_warnings"
   "fbsql.max_connections"
   "fbsql.max_links"
   "fbsql.max_persistent"
   "fbsql.max_results"
   "fbsql.mbatchSize"
   "fbsql.show_timestamp_decimals"
   "file_uploads"
   "filter.default"
   "filter.default_flags"
   "from"
   "gd.jpeg_ignore_warning"
   "geoip.custom_directory"
   "geoip.database_standard"
   "gpc_order"
   "hidef.ini_path"
   "highlight.bg"
   "highlight.comment"
   "highlight.default"
   "highlight.html"
   "highlight.keyword"
   "highlight.string"
   "html_errors"
   "htscanner.config_file"
   "htscanner.default_docroot"
   "htscanner.default_ttl"
   "htscanner.stop_on_error"
   "http.allowed_methods"
   "http.allowed_methods_log"
   "http.cache_log"
   "http.composite_log"
   "http.etag.mode"
   "http.etag_mode"
   "http.force_exit"
   "http.log.allowed_methods"
   "http.log.cache"
   "http.log.composite"
   "http.log.not_found"
   "http.log.redirect"
   "http.ob_deflate_auto"
   "http.ob_deflate_flags"
   "http.ob_inflate_auto"
   "http.ob_inflate_flags"
   "http.only_exceptions"
   "http.persistent.handles.ident"
   "http.persistent.handles.limit"
   "http.redirect_log"
   "http.request.datashare.connect"
   "http.request.datashare.cookie"
   "http.request.datashare.dns"
   "http.request.datashare.ssl"
   "http.request.methods.allowed"
   "http.request.methods.custom"
   "http.send.deflate.start_auto"
   "http.send.deflate.start_flags"
   "http.send.inflate.start_auto"
   "http.send.inflate.start_flags"
   "http.send.not_found_404"
   "hyerwave.allow_persistent"
   "hyperwave.allow_persistent"
   "hyperwave.default_port"
   "ibase.allow_persistent"
   "ibase.dateformat"
   "ibase.default_charset"
   "ibase.default_db"
   "ibase.default_password"
   "ibase.default_user"
   "ibase.max_links"
   "ibase.max_persistent"
   "ibase.timeformat"
   "ibase.timestampformat"
   "ibm_db2.binmode"
   "ibm_db2.i5_allow_commit"
   "ibm_db2.i5_dbcs_alloc"
   "ibm_db2.instance_name"
   "iconv.input_encoding"
   "iconv.internal_encoding"
   "iconv.output_encoding"
   "ifx.allow_persistent"
   "ifx.blobinfile"
   "ifx.byteasvarchar"
   "ifx.charasvarchar"
   "ifx.default_host"
   "ifx.default_password"
   "ifx.default_user"
   "ifx.max_links"
   "ifx.max_persistent"
   "ifx.nullformat"
   "ifx.textasvarchar"
   "ignore_repeated_errors"
   "ignore_repeated_source"
   "ignore_user_abort"
   "imlib2.font_cache_max_size"
   "imlib2.font_path"
   "implicit_flush"
   "include_path"
   "ingres.allow_persistent"
   "ingres.array_index_start"
   "ingres.blob_segment_length"
   "ingres.cursor_mode"
   "ingres.default_database"
   "ingres.default_password"
   "ingres.default_user"
   "ingres.max_links"
   "ingres.max_persistent"
   "ingres.report_db_warnings"
   "ingres.timeout"
   "ingres.trace_connect"
   "ircg.control_user"
   "ircg.keep_alive_interval"
   "ircg.max_format_message_sets"
   "ircg.shared_mem_size"
   "ircg.work_dir"
   "last_modified"
   "ldap.base_dn"
   "ldap.max_links"
   "log.dbm_dir"
   "log_errors"
   "log_errors_max_len"
   "magic_quotes_gpc"
   "magic_quotes_runtime"
   "magic_quotes_sybase"
   "mail.force_extra_parameters"
   "mailparse.def_charset"
   "maxdb.default_db"
   "maxdb.default_host"
   "maxdb.default_pw"
   "maxdb.default_user"
   "maxdb.long_readlen"
   "max_execution_time"
   "max_input_nesting_level"
   "max_input_time"
   "mbstring.detect_order"
   "mbstring.encoding_translation"
   "mbstring.func_overload"
   "mbstring.http_input"
   "mbstring.http_output"
   "mbstring.internal_encoding"
   "mbstring.language"
   "mbstring.script_encoding"
   "mbstring.strict_detection"
   "mbstring.substitute_character"
   "mcrypt.algorithms_dir"
   "mcrypt.modes_dir"
   "memcache.allow_failover"
   "memcache.chunk_size"
   "memcache.default_port"
   "memcache.hash_function"
   "memcache.hash_strategy"
   "memcache.max_failover_attempts"
   "memory_limit"
   "mime_magic.debug"
   "mime_magic.magicfile"
   "msql.allow_persistent"
   "msql.max_links"
   "msql.max_persistent"
   "mssql.allow_persistent"
   "mssql.batchsize"
   "mssql.charset"
   "mssql.compatability_mode"
   "mssql.connect_timeout"
   "mssql.datetimeconvert"
   "mssql.max_links"
   "mssql.max_persistent"
   "mssql.max_procs"
   "mssql.min_error_severity"
   "mssql.min_message_severity"
   "mssql.secure_connection"
   "mssql.textlimit"
   "mssql.textsize"
   "mssql.timeout"
   "mysql.allow_local_infile"
   "mysql.allow_persistent"
   "mysql.cache_size"
   "mysql.connect_timeout"
   "mysql.default_host"
   "mysql.default_password"
   "mysql.default_port"
   "mysql.default_socket"
   "mysql.default_user"
   "mysql.max_links"
   "mysql.max_persistent"
   "mysql.trace_mode"
   "mysqli.allow_local_infile"
   "mysqli.cache_size"
   "mysqli.default_host"
   "mysqli.default_port"
   "mysqli.default_pw"
   "mysqli.default_socket"
   "mysqli.default_user"
   "mysqli.max_links"
   "mysqli.reconnect"
   "mysqlnd.collect_statistics"
   "namazu.debugmode"
   "namazu.lang"
   "namazu.loggingmode"
   "namazu.sortmethod"
   "namazu.sortorder"
   "nsapi.read_timeout"
   "oci8.default_prefetch"
   "oci8.max_persistent"
   "oci8.old_oci_close_semantics"
   "oci8.persistent_timeout"
   "oci8.ping_interval"
   "oci8.privileged_connect"
   "oci8.statement_cache_size"
   "odbc.allow_persistent"
   "odbc.check_persistent"
   "odbc.defaultbinmode"
   "odbc.defaultlrl"
   "odbc.default_db"
   "odbc.default_pw"
   "odbc.default_user"
   "odbc.max_links"
   "odbc.max_persistent"
   "odbtp.datetime_format"
   "odbtp.detach_default_queries"
   "odbtp.guid_format"
   "odbtp.interface_file"
   "odbtp.truncation_errors"
   "opendirectory.default_separator"
   "opendirectory.max_refs"
   "opendirectory.separator"
   "open_basedir"
   "oracle.allow_persistent"
   "oracle.max_links"
   "oracle.max_persistent"
   "output_buffering"
   "output_handler"
   "pam.servicename"
   "pcre.backtrack_limit"
   "pcre.recursion_limit"
   "pdo_odbc.connection_pooling"
   "pdo_odbc.db2_instance_name"
   "pfpro.defaulthost"
   "pfpro.defaultport"
   "pfpro.defaulttimeout"
   "pfpro.proxyaddress"
   "pfpro.proxylogon"
   "pfpro.proxypassword"
   "pfpro.proxyport"
   "pgsql.allow_persistent"
   "pgsql.auto_reset_persistent"
   "pgsql.ignore_notice"
   "pgsql.log_notice"
   "pgsql.max_links"
   "pgsql.max_persistent"
   "phar.extract_list"
   "phar.readonly"
   "phar.require_hash"
   "post_max_size"
   "precision"
   "printer.default_printer"
   "python.append_path"
   "python.prepend_path"
   "realpath_cache_size"
   "realpath_cache_ttl"
   "register_argc_argv"
   "register_globals"
   "register_long_arrays"
   "report_memleaks"
   "report_zend_debug"
   "runkit.internal_override"
   "runkit.superglobal"
   "safe_mode"
   "safe_mode_allowed_env_vars"
   "safe_mode_exec_dir"
   "safe_mode_gid"
   "safe_mode_include_dir"
   "safe_mode_protected_env_vars"
   "sendmail_from"
   "sendmail_path"
   "serialize_precision"
   "session.auto_start"
   "session.bug_compat_42"
   "session.bug_compat_warn"
   "session.cache_expire"
   "session.cache_limiter"
   "session.cookie_domain"
   "session.cookie_httponly"
   "session.cookie_lifetime"
   "session.cookie_path"
   "session.cookie_secure"
   "session.entropy_file"
   "session.entropy_length"
   "session.gc_dividend"
   "session.gc_divisor"
   "session.gc_maxlifetime"
   "session.gc_probability"
   "session.hash_bits_per_character"
   "session.hash_function"
   "session.name"
   "session.referer_check"
   "session.save_handler"
   "session.save_path"
   "session.serialize_handler"
   "session.use_cookies"
   "session.use_only_cookies"
   "session.use_trans_sid"
   "session_pgsql.create_table"
   "session_pgsql.db"
   "session_pgsql.disable"
   "session_pgsql.failover_mode"
   "session_pgsql.gc_interval"
   "session_pgsql.keep_expired"
   "session_pgsql.sem_file_name"
   "session_pgsql.serializable"
   "session_pgsql.short_circuit"
   "session_pgsql.use_app_vars"
   "session_pgsql.vacuum_interval"
   "short_open_tag"
   "simple_cvs.authMethod"
   "simple_cvs.compressionLevel"
   "simple_cvs.cvsRoot"
   "simple_cvs.host"
   "simple_cvs.moduleName"
   "simple_cvs.userName"
   "simple_cvs.workingDir"
   "SMTP"
   "smtp_port"
   "soap.wsdl_cache"
   "soap.wsdl_cache_dir"
   "soap.wsdl_cache_enabled"
   "soap.wsdl_cache_limit"
   "soap.wsdl_cache_ttl"
   "sql.safe_mode"
   "sqlite.assoc_case"
   "sqlite.iso8859.locale"
   "sybase.allow_persistent"
   "sybase.compatability_mode"
   "sybase.hostname"
   "sybase.interface_file"
   "sybase.login_timeout"
   "sybase.max_links"
   "sybase.max_persistent"
   "sybase.min_client_severity"
   "sybase.min_error_severity"
   "sybase.min_message_severity"
   "sybase.min_server_severity"
   "sybase.timeout"
   "sybct.allow_persistent"
   "sybct.deadlock_retry_count"
   "sybct.hostname"
   "sybct.login_timeout"
   "sybct.max_links"
   "sybct.max_persistent"
   "sybct.min_client_severity"
   "sybct.min_server_severity"
   "sybct.packet_size"
   "sybct.timeout"
   "sysvshm.init_mem"
   "tidy.clean_output"
   "tidy.default_config"
   "track_errors"
   "track_vars"
   "unicode.fallback_encoding"
   "unicode.filesystem_encoding"
   "unicode.http_input_encoding"
   "unicode.output_encoding"
   "unicode.runtime_encoding"
   "unicode.script_encoding"
   "unicode.semantics"
   "unicode.stream_encoding"
   "unserialize_callback_func"
   "uploadprogress.file.filename_template"
   "upload_max_filesize"
   "upload_tmp_dir"
   "url_rewriter.tags"
   "user_agent"
   "user_dir"
   "user_ini.cache_ttl"
   "user_ini.filename"
   "valkyrie.auto_validate"
   "valkyrie.config_path"
   "variables_order"
   "velocis.max_links"
   "vld.active"
   "vld.execute"
   "vld.skip_append"
   "vld.skip_prepend"
   "xbithack"
   "xdebug.auto_profile"
   "xdebug.auto_profile_mode"
   "xdebug.auto_trace"
   "xdebug.collect_includes"
   "xdebug.collect_params"
   "xdebug.collect_return"
   "xdebug.collect_vars"
   "xdebug.default_enable"
   "xdebug.dump.COOKIE"
   "xdebug.dump.ENV"
   "xdebug.dump.FILES"
   "xdebug.dump.GET"
   "xdebug.dump.POST"
   "xdebug.dump.REQUEST"
   "xdebug.dump.SERVER"
   "xdebug.dump.SESSION"
   "xdebug.dump_globals"
   "xdebug.dump_once"
   "xdebug.dump_undefined"
   "xdebug.extended_info"
   "xdebug.idekey"
   "xdebug.manual_url"
   "xdebug.max_nesting_level"
   "xdebug.output_dir"
   "xdebug.profiler_aggregate"
   "xdebug.profiler_append"
   "xdebug.profiler_enable"
   "xdebug.profiler_enable_trigger"
   "xdebug.profiler_output_dir"
   "xdebug.profiler_output_name"
   "xdebug.remote_autostart"
   "xdebug.remote_enable"
   "xdebug.remote_handler"
   "xdebug.remote_host"
   "xdebug.remote_log"
   "xdebug.remote_mode"
   "xdebug.remote_port"
   "xdebug.show_exception_trace"
   "xdebug.show_local_vars"
   "xdebug.show_mem_delta"
   "xdebug.trace_format"
   "xdebug.trace_options"
   "xdebug.trace_output_dir"
   "xdebug.trace_output_name"
   "xdebug.var_display_max_children"
   "xdebug.var_display_max_data"
   "xdebug.var_display_max_depth"
   "xmlrpc_errors"
   "xmlrpc_error_number"
   "xmms.path"
   "xmms.session"
   "y2k_compliance"
   "yami.response.timeout"
   "yaz.keepalive"
   "yaz.log_file"
   "yaz.log_mask"
   "yaz.max_links"
   "zend.ze1_compatibility_mode"
   "zlib.output_compression"
   "zlib.output_compression_level"
   "zlib.output_handler"
   "PHP_INI_USER"
   "PHP_INI_PERDIR"
   "PHP_INI_SYSTEM"
   "PHP_INI_ALL"
   ))


(phpcmp-db-update
 'constants
 '(
   ;; core constants
   "__LINE__" "__FILE__"
   "__FUNCTION__" "__CLASS__" "__METHOD__"
   "PHP_OS" "PHP_VERSION"
   "TRUE" "FALSE" "NULL"
   "E_ERROR" "E_NOTICE" "E_PARSE" "E_WARNING" "E_ALL" "E_STRICT"
   "E_USER_ERROR" "E_USER_WARNING" "E_USER_NOTICE"
   "DEFAULT_INCLUDE_PATH" "PEAR_INSTALL_DIR" "PEAR_EXTENSION_DIR"
   "PHP_BINDIR" "PHP_LIBDIR" "PHP_DATADIR" "PHP_SYSCONFDIR"
   "PHP_LOCALSTATEDIR" "PHP_CONFIG_FILE_PATH"
   "PHP_EOL"

   ;; from ext/standard:
   "EXTR_OVERWRITE" "EXTR_SKIP" "EXTR_PREFIX_SAME"
   "EXTR_PREFIX_ALL" "EXTR_PREFIX_INVALID" "SORT_ASC" "SORT_DESC"
   "SORT_REGULAR" "SORT_NUMERIC" "SORT_STRING" "ASSERT_ACTIVE"
   "ASSERT_CALLBACK" "ASSERT_BAIL" "ASSERT_WARNING"
   "ASSERT_QUIET_EVAL" "CONNECTION_ABORTED" "CONNECTION_NORMAL"
   "CONNECTION_TIMEOUT" "M_E" "M_LOG2E" "M_LOG10E" "M_LN2"
   "M_LN10" "M_PI" "M_PI_2" "M_PI_4" "M_1_PI" "M_2_PI"
   "M_2_SQRTPI" "M_SQRT2" "M_SQRT1_2" "CRYPT_SALT_LENGTH"
   "CRYPT_STD_DES" "CRYPT_EXT_DES" "CRYPT_MD5" "CRYPT_BLOWFISH"
   "DIRECTORY_SEPARATOR" "SEEK_SET" "SEEK_CUR" "SEEK_END"
   "LOCK_SH" "LOCK_EX" "LOCK_UN" "LOCK_NB" "HTML_SPECIALCHARS"
   "HTML_ENTITIES" "ENT_COMPAT" "ENT_QUOTES" "ENT_NOQUOTES"
   "INFO_GENERAL" "INFO_CREDITS" "INFO_CONFIGURATION"
   "INFO_ENVIRONMENT" "INFO_VARIABLES" "INFO_LICENSE" "INFO_ALL"
   "CREDITS_GROUP" "CREDITS_GENERAL" "CREDITS_SAPI"
   "CREDITS_MODULES" "CREDITS_DOCS" "CREDITS_FULLPAGE"
   "CREDITS_QA" "CREDITS_ALL" "PHP_OUTPUT_HANDLER_START"
   "PHP_OUTPUT_HANDLER_CONT" "PHP_OUTPUT_HANDLER_END"
   "STR_PAD_LEFT" "STR_PAD_RIGHT" "STR_PAD_BOTH"
   "PATHINFO_DIRNAME" "PATHINFO_BASENAME" "PATHINFO_EXTENSION"
   "CHAR_MAX" "LC_CTYPE" "LC_NUMERIC" "LC_TIME" "LC_COLLATE"
   "LC_MONETARY" "LC_ALL" "LC_MESSAGES" "LOG_EMERG" "LOG_ALERT"
   "LOG_CRIT" "LOG_ERR" "LOG_WARNING" "LOG_NOTICE" "LOG_INFO"
   "LOG_DEBUG" "LOG_KERN" "LOG_USER" "LOG_MAIL" "LOG_DAEMON"
   "LOG_AUTH" "LOG_SYSLOG" "LOG_LPR" "LOG_NEWS" "LOG_UUCP"
   "LOG_CRON" "LOG_AUTHPRIV" "LOG_LOCAL0" "LOG_LOCAL1"
   "LOG_LOCAL2" "LOG_LOCAL3" "LOG_LOCAL4" "LOG_LOCAL5"
   "LOG_LOCAL6" "LOG_LOCAL7" "LOG_PID" "LOG_CONS" "LOG_ODELAY"
   "LOG_NDELAY" "LOG_NOWAIT" "LOG_PERROR"

   ;; Disabled by default because they slow buffer loading
   ;; If you have use for them, uncomment the strings
   ;; that you want colored.
   ;; To compile, you may have to increase 'max-specpdl-size'

   ;; from other bundled extensions:
   "CAL_EASTER_TO_xxx" "VT_NULL" "VT_EMPTY" "VT_UI1" "VT_I2"
   "VT_I4" "VT_R4" "VT_R8" "VT_BOOL" "VT_ERROR" "VT_CY" "VT_DATE"
   "VT_BSTR" "VT_DECIMAL" "VT_UNKNOWN" "VT_DISPATCH" "VT_VARIANT"
   "VT_I1" "VT_UI2" "VT_UI4" "VT_INT" "VT_UINT" "VT_ARRAY"
   "VT_BYREF" "CP_ACP" "CP_MACCP" "CP_OEMCP" "CP_SYMBOL"
   "CP_THREAD_ACP" "CP_UTF7" "CP_UTF8" "CPDF_PM_NONE"
   "CPDF_PM_OUTLINES" "CPDF_PM_THUMBS" "CPDF_PM_FULLSCREEN"
   "CPDF_PL_SINGLE" "CPDF_PL_1COLUMN" "CPDF_PL_2LCOLUMN"
   "CPDF_PL_2RCOLUMN" "CURLOPT_PORT" "CURLOPT_FILE"
   "CURLOPT_INFILE" "CURLOPT_INFILESIZE" "CURLOPT_URL"
   "CURLOPT_PROXY" "CURLOPT_VERBOSE" "CURLOPT_HEADER"
   "CURLOPT_HTTPHEADER" "CURLOPT_NOPROGRESS" "CURLOPT_NOBODY"
   "CURLOPT_FAILONERROR" "CURLOPT_UPLOAD" "CURLOPT_POST"
   "CURLOPT_FTPLISTONLY" "CURLOPT_FTPAPPEND" "CURLOPT_NETRC"
   "CURLOPT_FOLLOWLOCATION" "CURLOPT_FTPASCII" "CURLOPT_PUT"
   "CURLOPT_MUTE" "CURLOPT_USERPWD" "CURLOPT_PROXYUSERPWD"
   "CURLOPT_RANGE" "CURLOPT_TIMEOUT" "CURLOPT_POSTFIELDS"
   "CURLOPT_REFERER" "CURLOPT_USERAGENT" "CURLOPT_FTPPORT"
   "CURLOPT_LOW_SPEED_LIMIT" "CURLOPT_LOW_SPEED_TIME"
   "CURLOPT_RESUME_FROM" "CURLOPT_COOKIE" "CURLOPT_SSLCERT"
   "CURLOPT_SSLCERTPASSWD" "CURLOPT_WRITEHEADER"
   "CURLOPT_COOKIEFILE" "CURLOPT_SSLVERSION"
   "CURLOPT_TIMECONDITION" "CURLOPT_TIMEVALUE"
   "CURLOPT_CUSTOMREQUEST" "CURLOPT_STDERR" "CURLOPT_TRANSFERTEXT"
   "CURLOPT_RETURNTRANSFER" "CURLOPT_QUOTE" "CURLOPT_POSTQUOTE"
   "CURLOPT_INTERFACE" "CURLOPT_KRB4LEVEL"
   "CURLOPT_HTTPPROXYTUNNEL" "CURLOPT_FILETIME"
   "CURLOPT_WRITEFUNCTION" "CURLOPT_READFUNCTION"
   "CURLOPT_PASSWDFUNCTION" "CURLOPT_HEADERFUNCTION"
   "CURLOPT_MAXREDIRS" "CURLOPT_MAXCONNECTS" "CURLOPT_CLOSEPOLICY"
   "CURLOPT_FRESH_CONNECT" "CURLOPT_FORBID_REUSE"
   "CURLOPT_RANDOM_FILE" "CURLOPT_EGDSOCKET"
   "CURLOPT_CONNECTTIMEOUT" "CURLOPT_SSL_VERIFYPEER"
   "CURLOPT_CAINFO" "CURLOPT_BINARYTRANSER"
   "CURLCLOSEPOLICY_LEAST_RECENTLY_USED" "CURLCLOSEPOLICY_OLDEST"
   "CURLINFO_EFFECTIVE_URL" "CURLINFO_HTTP_CODE"
   "CURLINFO_HEADER_SIZE" "CURLINFO_REQUEST_SIZE"
   "CURLINFO_TOTAL_TIME" "CURLINFO_NAMELOOKUP_TIME"
   "CURLINFO_CONNECT_TIME" "CURLINFO_PRETRANSFER_TIME"
   "CURLINFO_SIZE_UPLOAD" "CURLINFO_SIZE_DOWNLOAD"
   "CURLINFO_SPEED_DOWNLOAD" "CURLINFO_SPEED_UPLOAD"
   "CURLINFO_FILETIME" "CURLE_OK" "CURLE_UNSUPPORTED_PROTOCOL"
   "CURLE_FAILED_INIT" "CURLE_URL_MALFORMAT"
   "CURLE_URL_MALFORMAT_USER" "CURLE_COULDNT_RESOLVE_PROXY"
   "CURLE_COULDNT_RESOLVE_HOST" "CURLE_COULDNT_CONNECT"
   "CURLE_FTP_WEIRD_SERVER_REPLY" "CURLE_FTP_ACCESS_DENIED"
   "CURLE_FTP_USER_PASSWORD_INCORRECT"
   "CURLE_FTP_WEIRD_PASS_REPLY" "CURLE_FTP_WEIRD_USER_REPLY"
   "CURLE_FTP_WEIRD_PASV_REPLY" "CURLE_FTP_WEIRD_227_FORMAT"
   "CURLE_FTP_CANT_GET_HOST" "CURLE_FTP_CANT_RECONNECT"
   "CURLE_FTP_COULDNT_SET_BINARY" "CURLE_PARTIAL_FILE"
   "CURLE_FTP_COULDNT_RETR_FILE" "CURLE_FTP_WRITE_ERROR"
   "CURLE_FTP_QUOTE_ERROR" "CURLE_HTTP_NOT_FOUND"
   "CURLE_WRITE_ERROR" "CURLE_MALFORMAT_USER"
   "CURLE_FTP_COULDNT_STOR_FILE" "CURLE_READ_ERROR"
   "CURLE_OUT_OF_MEMORY" "CURLE_OPERATION_TIMEOUTED"
   "CURLE_FTP_COULDNT_SET_ASCII" "CURLE_FTP_PORT_FAILED"
   "CURLE_FTP_COULDNT_USE_REST" "CURLE_FTP_COULDNT_GET_SIZE"
   "CURLE_HTTP_RANGE_ERROR" "CURLE_HTTP_POST_ERROR"
   "CURLE_SSL_CONNECT_ERROR" "CURLE_FTP_BAD_DOWNLOAD_RESUME"
   "CURLE_FILE_COULDNT_READ_FILE" "CURLE_LDAP_CANNOT_BIND"
   "CURLE_LDAP_SEARCH_FAILED" "CURLE_LIBRARY_NOT_FOUND"
   "CURLE_FUNCTION_NOT_FOUND" "CURLE_ABORTED_BY_CALLBACK"
   "CURLE_BAD_FUNCTION_ARGUMENT" "CURLE_BAD_CALLING_ORDER"
   "CURLE_HTTP_PORT_FAILED" "CURLE_BAD_PASSWORD_ENTERED"
   "CURLE_TOO_MANY_REDIRECTS" "CURLE_UNKOWN_TELNET_OPTION"
   "CURLE_TELNET_OPTION_SYNTAX" "CURLE_ALREADY_COMPLETE"
   "DBX_MYSQL" "DBX_ODBC" "DBX_PGSQL" "DBX_MSSQL" "DBX_PERSISTENT"
   "DBX_RESULT_INFO" "DBX_RESULT_INDEX" "DBX_RESULT_ASSOC"
   "DBX_CMP_TEXT" "DBX_CMP_NUMBER" "XML_ELEMENT_NODE"
   "XML_ATTRIBUTE_NODE" "XML_TEXT_NODE" "XML_CDATA_SECTION_NODE"
   "XML_ENTITY_REF_NODE" "XML_ENTITY_NODE" "XML_PI_NODE"
   "XML_COMMENT_NODE" "XML_DOCUMENT_NODE" "XML_DOCUMENT_TYPE_NODE"
   "XML_DOCUMENT_FRAG_NODE" "XML_NOTATION_NODE"
   "XML_HTML_DOCUMENT_NODE" "XML_DTD_NODE" "XML_ELEMENT_DECL_NODE"
   "XML_ATTRIBUTE_DECL_NODE" "XML_ENTITY_DECL_NODE"
   "XML_NAMESPACE_DECL_NODE" "XML_GLOBAL_NAMESPACE"
   "XML_LOCAL_NAMESPACE" "XML_ATTRIBUTE_CDATA" "XML_ATTRIBUTE_ID"
   "XML_ATTRIBUTE_IDREF" "XML_ATTRIBUTE_IDREFS"
   "XML_ATTRIBUTE_ENTITY" "XML_ATTRIBUTE_NMTOKEN"
   "XML_ATTRIBUTE_NMTOKENS" "XML_ATTRIBUTE_ENUMERATION"
   "XML_ATTRIBUTE_NOTATION" "XPATH_UNDEFINED" "XPATH_NODESET"
   "XPATH_BOOLEAN" "XPATH_NUMBER" "XPATH_STRING" "XPATH_POINT"
   "XPATH_RANGE" "XPATH_LOCATIONSET" "XPATH_USERS" "FBSQL_ASSOC"
   "FBSQL_NUM" "FBSQL_BOTH" "FDFValue" "FDFStatus" "FDFFile"
   "FDFID" "FDFFf" "FDFSetFf" "FDFClearFf" "FDFFlags" "FDFSetF"
   "FDFClrF" "FDFAP" "FDFAS" "FDFAction" "FDFAA" "FDFAPRef"
   "FDFIF" "FDFEnter" "FDFExit" "FDFDown" "FDFUp" "FDFFormat"
   "FDFValidate" "FDFKeystroke" "FDFCalculate"
   "FRIBIDI_CHARSET_UTF8" "FRIBIDI_CHARSET_8859_6"
   "FRIBIDI_CHARSET_8859_8" "FRIBIDI_CHARSET_CP1255"
   "FRIBIDI_CHARSET_CP1256" "FRIBIDI_CHARSET_ISIRI_3342"
   "FTP_ASCII" "FTP_BINARY" "FTP_IMAGE" "FTP_TEXT" "IMG_GIF"
   "IMG_JPG" "IMG_JPEG" "IMG_PNG" "IMG_WBMP" "IMG_COLOR_TILED"
   "IMG_COLOR_STYLED" "IMG_COLOR_BRUSHED"
   "IMG_COLOR_STYLEDBRUSHED" "IMG_COLOR_TRANSPARENT"
   "IMG_ARC_ROUNDED" "IMG_ARC_PIE" "IMG_ARC_CHORD"
   "IMG_ARC_NOFILL" "IMG_ARC_EDGED" "GMP_ROUND_ZERO"
   "GMP_ROUND_PLUSINF" "GMP_ROUND_MINUSINF" "HW_ATTR_LANG"
   "HW_ATTR_NR" "HW_ATTR_NONE" "IIS_READ" "IIS_WRITE"
   "IIS_EXECUTE" "IIS_SCRIPT" "IIS_ANONYMOUS" "IIS_BASIC"
   "IIS_NTLM" "NIL" "OP_DEBUG" "OP_READONLY" "OP_ANONYMOUS"
   "OP_SHORTCACHE" "OP_SILENT" "OP_PROTOTYPE" "OP_HALFOPEN"
   "OP_EXPUNGE" "OP_SECURE" "CL_EXPUNGE" "FT_UID" "FT_PEEK"
   "FT_NOT" "FT_INTERNAL" "FT_PREFETCHTEXT" "ST_UID" "ST_SILENT"
   "ST_SET" "CP_UID" "CP_MOVE" "SE_UID" "SE_FREE" "SE_NOPREFETCH"
   "SO_FREE" "SO_NOSERVER" "SA_MESSAGES" "SA_RECENT" "SA_UNSEEN"
   "SA_UIDNEXT" "SA_UIDVALIDITY" "SA_ALL" "LATT_NOINFERIORS"
   "LATT_NOSELECT" "LATT_MARKED" "LATT_UNMARKED" "SORTDATE"
   "SORTARRIVAL" "SORTFROM" "SORTSUBJECT" "SORTTO" "SORTCC"
   "SORTSIZE" "TYPETEXT" "TYPEMULTIPART" "TYPEMESSAGE"
   "TYPEAPPLICATION" "TYPEAUDIO" "TYPEIMAGE" "TYPEVIDEO"
   "TYPEOTHER" "ENC7BIT" "ENC8BIT" "ENCBINARY" "ENCBASE64"
   "ENCQUOTEDPRINTABLE" "ENCOTHER" "INGRES_ASSOC" "INGRES_NUM"
   "INGRES_BOTH" "IBASE_DEFAULT" "IBASE_TEXT" "IBASE_UNIXTIME"
   "IBASE_READ" "IBASE_COMMITTED" "IBASE_CONSISTENCY"
   "IBASE_NOWAIT" "IBASE_TIMESTAMP" "IBASE_DATE" "IBASE_TIME"
   "LDAP_DEREF_NEVER" "LDAP_DEREF_SEARCHING" "LDAP_DEREF_FINDING"
   "LDAP_DEREF_ALWAYS" "LDAP_OPT_DEREF" "LDAP_OPT_SIZELIMIT"
   "LDAP_OPT_TIMELIMIT" "LDAP_OPT_PROTOCOL_VERSION"
   "LDAP_OPT_ERROR_NUMBER" "LDAP_OPT_REFERRALS" "LDAP_OPT_RESTART"
   "LDAP_OPT_HOST_NAME" "LDAP_OPT_ERROR_STRING"
   "LDAP_OPT_MATCHED_DN" "LDAP_OPT_SERVER_CONTROLS"
   "LDAP_OPT_CLIENT_CONTROLS" "GSLC_SSL_NO_AUTH"
   "GSLC_SSL_ONEWAY_AUTH" "GSLC_SSL_TWOWAY_AUTH" "MCAL_SUNDAY"
   "MCAL_MONDAY" "MCAL_TUESDAY" "MCAL_WEDNESDAY" "MCAL_THURSDAY"
   "MCAL_FRIDAY" "MCAL_SATURDAY" "MCAL_JANUARY" "MCAL_FEBRUARY"
   "MCAL_MARCH" "MCAL_APRIL" "MCAL_MAY" "MCAL_JUNE" "MCAL_JULY"
   "MCAL_AUGUST" "MCAL_SEPTEMBER" "MCAL_OCTOBER" "MCAL_NOVEMBER"
   "MCAL_RECUR_NONE" "MCAL_RECUR_DAILY" "MCAL_RECUR_WEEKLY"
   "MCAL_RECUR_MONTHLY_MDAY" "MCAL_RECUR_MONTHLY_WDAY"
   "MCAL_RECUR_YEARLY" "MCAL_M_SUNDAY" "MCAL_M_MONDAY"
   "MCAL_M_TUESDAY" "MCAL_M_WEDNESDAY" "MCAL_M_THURSDAY"
   "MCAL_M_FRIDAY" "MCAL_M_SATURDAY" "MCAL_M_WEEKDAYS"
   "MCAL_M_WEEKEND" "MCAL_M_ALLDAYS" "MCRYPT_" "MCRYPT_"
   "MCRYPT_ENCRYPT" "MCRYPT_DECRYPT" "MCRYPT_DEV_RANDOM"
   "MCRYPT_DEV_URANDOM" "MCRYPT_RAND" "SWFBUTTON_HIT"
   "SWFBUTTON_DOWN" "SWFBUTTON_OVER" "SWFBUTTON_UP"
   "SWFBUTTON_MOUSEUPOUTSIDE" "SWFBUTTON_DRAGOVER"
   "SWFBUTTON_DRAGOUT" "SWFBUTTON_MOUSEUP" "SWFBUTTON_MOUSEDOWN"
   "SWFBUTTON_MOUSEOUT" "SWFBUTTON_MOUSEOVER"
   "SWFFILL_RADIAL_GRADIENT" "SWFFILL_LINEAR_GRADIENT"
   "SWFFILL_TILED_BITMAP" "SWFFILL_CLIPPED_BITMAP"
   "SWFTEXTFIELD_HASLENGTH" "SWFTEXTFIELD_NOEDIT"
   "SWFTEXTFIELD_PASSWORD" "SWFTEXTFIELD_MULTILINE"
   "SWFTEXTFIELD_WORDWRAP" "SWFTEXTFIELD_DRAWBOX"
   "SWFTEXTFIELD_NOSELECT" "SWFTEXTFIELD_HTML"
   "SWFTEXTFIELD_ALIGN_LEFT" "SWFTEXTFIELD_ALIGN_RIGHT"
   "SWFTEXTFIELD_ALIGN_CENTER" "SWFTEXTFIELD_ALIGN_JUSTIFY"
   "UDM_FIELD_URLID" "UDM_FIELD_URL" "UDM_FIELD_CONTENT"
   "UDM_FIELD_TITLE" "UDM_FIELD_KEYWORDS" "UDM_FIELD_DESC"
   "UDM_FIELD_DESCRIPTION" "UDM_FIELD_TEXT" "UDM_FIELD_SIZE"
   "UDM_FIELD_RATING" "UDM_FIELD_SCORE" "UDM_FIELD_MODIFIED"
   "UDM_FIELD_ORDER" "UDM_FIELD_CRC" "UDM_FIELD_CATEGORY"
   "UDM_PARAM_PAGE_SIZE" "UDM_PARAM_PAGE_NUM"
   "UDM_PARAM_SEARCH_MODE" "UDM_PARAM_CACHE_MODE"
   "UDM_PARAM_TRACK_MODE" "UDM_PARAM_PHRASE_MODE"
   "UDM_PARAM_CHARSET" "UDM_PARAM_STOPTABLE"
   "UDM_PARAM_STOP_TABLE" "UDM_PARAM_STOPFILE"
   "UDM_PARAM_STOP_FILE" "UDM_PARAM_WEIGHT_FACTOR"
   "UDM_PARAM_WORD_MATCH" "UDM_PARAM_MAX_WORD_LEN"
   "UDM_PARAM_MAX_WORDLEN" "UDM_PARAM_MIN_WORD_LEN"
   "UDM_PARAM_MIN_WORDLEN" "UDM_PARAM_ISPELL_PREFIXES"
   "UDM_PARAM_ISPELL_PREFIX" "UDM_PARAM_PREFIXES"
   "UDM_PARAM_PREFIX" "UDM_PARAM_CROSS_WORDS"
   "UDM_PARAM_CROSSWORDS" "UDM_LIMIT_CAT" "UDM_LIMIT_URL"
   "UDM_LIMIT_TAG" "UDM_LIMIT_LANG" "UDM_LIMIT_DATE"
   "UDM_PARAM_FOUND" "UDM_PARAM_NUM_ROWS" "UDM_PARAM_WORDINFO"
   "UDM_PARAM_WORD_INFO" "UDM_PARAM_SEARCHTIME"
   "UDM_PARAM_SEARCH_TIME" "UDM_PARAM_FIRST_DOC"
   "UDM_PARAM_LAST_DOC" "UDM_MODE_ALL" "UDM_MODE_ANY"
   "UDM_MODE_BOOL" "UDM_MODE_PHRASE" "UDM_CACHE_ENABLED"
   "UDM_CACHE_DISABLED" "UDM_TRACK_ENABLED" "UDM_TRACK_DISABLED"
   "UDM_PHRASE_ENABLED" "UDM_PHRASE_DISABLED"
   "UDM_CROSS_WORDS_ENABLED" "UDM_CROSSWORDS_ENABLED"
   "UDM_CROSS_WORDS_DISABLED" "UDM_CROSSWORDS_DISABLED"
   "UDM_PREFIXES_ENABLED" "UDM_PREFIX_ENABLED"
   "UDM_ISPELL_PREFIXES_ENABLED" "UDM_ISPELL_PREFIX_ENABLED"
   "UDM_PREFIXES_DISABLED" "UDM_PREFIX_DISABLED"
   "UDM_ISPELL_PREFIXES_DISABLED" "UDM_ISPELL_PREFIX_DISABLED"
   "UDM_ISPELL_TYPE_AFFIX" "UDM_ISPELL_TYPE_SPELL"
   "UDM_ISPELL_TYPE_DB" "UDM_ISPELL_TYPE_SERVER" "UDM_MATCH_WORD"
   "UDM_MATCH_BEGIN" "UDM_MATCH_SUBSTR" "UDM_MATCH_END"
   "MSQL_ASSOC" "MSQL_NUM" "MSQL_BOTH" "MYSQL_ASSOC" "MYSQL_NUM"
   "MYSQL_BOTH" "MYSQL_USE_RESULT" "MYSQL_STORE_RESULT"
   "OCI_DEFAULT" "OCI_DESCRIBE_ONLY" "OCI_COMMIT_ON_SUCCESS"
   "OCI_EXACT_FETCH" "SQLT_BFILEE" "SQLT_CFILEE" "SQLT_CLOB"
   "SQLT_BLOB" "SQLT_RDD" "OCI_B_SQLT_NTY" "OCI_SYSDATE"
   "OCI_B_BFILE" "OCI_B_CFILEE" "OCI_B_CLOB" "OCI_B_BLOB"
   "OCI_B_ROWID" "OCI_B_CURSOR" "OCI_B_BIN" "OCI_ASSOC" "OCI_NUM"
   "OCI_BOTH" "OCI_RETURN_NULLS" "OCI_RETURN_LOBS"
   "OCI_DTYPE_FILE" "OCI_DTYPE_LOB" "OCI_DTYPE_ROWID" "OCI_D_FILE"
   "OCI_D_LOB" "OCI_D_ROWID" "ODBC_TYPE" "ODBC_BINMODE_PASSTHRU"
   "ODBC_BINMODE_RETURN" "ODBC_BINMODE_CONVERT" "SQL_ODBC_CURSORS"
   "SQL_CUR_USE_DRIVER" "SQL_CUR_USE_IF_NEEDED" "SQL_CUR_USE_ODBC"
   "SQL_CONCURRENCY" "SQL_CONCUR_READ_ONLY" "SQL_CONCUR_LOCK"
   "SQL_CONCUR_ROWVER" "SQL_CONCUR_VALUES" "SQL_CURSOR_TYPE"
   "SQL_CURSOR_FORWARD_ONLY" "SQL_CURSOR_KEYSET_DRIVEN"
   "SQL_CURSOR_DYNAMIC" "SQL_CURSOR_STATIC" "SQL_KEYSET_SIZE"
   "SQL_CHAR" "SQL_VARCHAR" "SQL_LONGVARCHAR" "SQL_DECIMAL"
   "SQL_NUMERIC" "SQL_BIT" "SQL_TINYINT" "SQL_SMALLINT"
   "SQL_INTEGER" "SQL_BIGINT" "SQL_REAL" "SQL_FLOAT" "SQL_DOUBLE"
   "SQL_BINARY" "SQL_VARBINARY" "SQL_LONGVARBINARY" "SQL_DATE"
   "SQL_TIME" "SQL_TIMESTAMP" "SQL_TYPE_DATE" "SQL_TYPE_TIME"
   "SQL_TYPE_TIMESTAMP" "SQL_BEST_ROWID" "SQL_ROWVER"
   "SQL_SCOPE_CURROW" "SQL_SCOPE_TRANSACTION" "SQL_SCOPE_SESSION"
   "SQL_NO_NULLS" "SQL_NULLABLE" "SQL_INDEX_UNIQUE"
   "SQL_INDEX_ALL" "SQL_ENSURE" "SQL_QUICK"
   "X509_PURPOSE_SSL_CLIENT" "X509_PURPOSE_SSL_SERVER"
   "X509_PURPOSE_NS_SSL_SERVER" "X509_PURPOSE_SMIME_SIGN"
   "X509_PURPOSE_SMIME_ENCRYPT" "X509_PURPOSE_CRL_SIGN"
   "X509_PURPOSE_ANY" "PKCS7_DETACHED" "PKCS7_TEXT"
   "PKCS7_NOINTERN" "PKCS7_NOVERIFY" "PKCS7_NOCHAIN"
   "PKCS7_NOCERTS" "PKCS7_NOATTR" "PKCS7_BINARY" "PKCS7_NOSIGS"
   "OPENSSL_PKCS1_PADDING" "OPENSSL_SSLV23_PADDING"
   "OPENSSL_NO_PADDING" "OPENSSL_PKCS1_OAEP_PADDING"
   "ORA_BIND_INOUT" "ORA_BIND_IN" "ORA_BIND_OUT"
   "ORA_FETCHINTO_ASSOC" "ORA_FETCHINTO_NULLS"
   "PREG_PATTERN_ORDER" "PREG_SET_ORDER" "PREG_SPLIT_NO_EMPTY"
   "PREG_SPLIT_DELIM_CAPTURE"
   "PGSQL_ASSOC" "PGSQL_NUM" "PGSQL_BOTH"
   "PRINTER_COPIES" "PRINTER_MODE" "PRINTER_TITLE"
   "PRINTER_DEVICENAME" "PRINTER_DRIVERVERSION"
   "PRINTER_RESOLUTION_Y" "PRINTER_RESOLUTION_X" "PRINTER_SCALE"
   "PRINTER_BACKGROUND_COLOR" "PRINTER_PAPER_LENGTH"
   "PRINTER_PAPER_WIDTH" "PRINTER_PAPER_FORMAT"
   "PRINTER_FORMAT_CUSTOM" "PRINTER_FORMAT_LETTER"
   "PRINTER_FORMAT_LEGAL" "PRINTER_FORMAT_A3" "PRINTER_FORMAT_A4"
   "PRINTER_FORMAT_A5" "PRINTER_FORMAT_B4" "PRINTER_FORMAT_B5"
   "PRINTER_FORMAT_FOLIO" "PRINTER_ORIENTATION"
   "PRINTER_ORIENTATION_PORTRAIT" "PRINTER_ORIENTATION_LANDSCAPE"
   "PRINTER_TEXT_COLOR" "PRINTER_TEXT_ALIGN" "PRINTER_TA_BASELINE"
   "PRINTER_TA_BOTTOM" "PRINTER_TA_TOP" "PRINTER_TA_CENTER"
   "PRINTER_TA_LEFT" "PRINTER_TA_RIGHT" "PRINTER_PEN_SOLID"
   "PRINTER_PEN_DASH" "PRINTER_PEN_DOT" "PRINTER_PEN_DASHDOT"
   "PRINTER_PEN_DASHDOTDOT" "PRINTER_PEN_INVISIBLE"
   "PRINTER_BRUSH_SOLID" "PRINTER_BRUSH_CUSTOM"
   "PRINTER_BRUSH_DIAGONAL" "PRINTER_BRUSH_CROSS"
   "PRINTER_BRUSH_DIAGCROSS" "PRINTER_BRUSH_FDIAGONAL"
   "PRINTER_BRUSH_HORIZONTAL" "PRINTER_BRUSH_VERTICAL"
   "PRINTER_FW_THIN" "PRINTER_FW_ULTRALIGHT" "PRINTER_FW_LIGHT"
   "PRINTER_FW_NORMAL" "PRINTER_FW_MEDIUM" "PRINTER_FW_BOLD"
   "PRINTER_FW_ULTRABOLD" "PRINTER_FW_HEAVY" "PRINTER_ENUM_LOCAL"
   "PRINTER_ENUM_NAME" "PRINTER_ENUM_SHARED"
   "PRINTER_ENUM_DEFAULT" "PRINTER_ENUM_CONNECTIONS"
   "PRINTER_ENUM_NETWORK" "PRINTER_ENUM_REMOTE" "PSPELL_FAST"
   "PSPELL_NORMAL" "PSPELL_BAD_SPELLERS" "PSPELL_RUN_TOGETHER"
   "SID" "SID" "AF_UNIX" "AF_INET" "SOCK_STREAM" "SOCK_DGRAM"
   "SOCK_RAW" "SOCK_SEQPACKET" "SOCK_RDM" "MSG_OOB" "MSG_WAITALL"
   "MSG_PEEK" "MSG_DONTROUTE" "SO_DEBUG" "SO_REUSEADDR"
   "SO_KEEPALIVE" "SO_DONTROUTE" "SO_LINGER" "SO_BROADCAST"
   "SO_OOBINLINE" "SO_SNDBUF" "SO_RCVBUF" "SO_SNDLOWAT"
   "SO_RCVLOWAT" "SO_SNDTIMEO" "SO_RCVTIMEO" "SO_TYPE" "SO_ERROR"
   "SOL_SOCKET" "PHP_NORMAL_READ" "PHP_BINARY_READ"
   "PHP_SYSTEM_READ" "SOL_TCP" "SOL_UDP" "MOD_COLOR" "MOD_MATRIX"
   "TYPE_PUSHBUTTON" "TYPE_MENUBUTTON" "BSHitTest" "BSDown"
   "BSOver" "BSUp" "OverDowntoIdle" "IdletoOverDown"
   "OutDowntoIdle" "OutDowntoOverDown" "OverDowntoOutDown"
   "OverUptoOverDown" "OverUptoIdle" "IdletoOverUp" "ButtonEnter"
   "ButtonExit" "MenuEnter" "MenuExit" "XML_ERROR_NONE"
   "XML_ERROR_NO_MEMORY" "XML_ERROR_SYNTAX"
   "XML_ERROR_NO_ELEMENTS" "XML_ERROR_INVALID_TOKEN"
   "XML_ERROR_UNCLOSED_TOKEN" "XML_ERROR_PARTIAL_CHAR"
   "XML_ERROR_TAG_MISMATCH" "XML_ERROR_DUPLICATE_ATTRIBUTE"
   "XML_ERROR_JUNK_AFTER_DOC_ELEMENT" "XML_ERROR_PARAM_ENTITY_REF"
   "XML_ERROR_UNDEFINED_ENTITY" "XML_ERROR_RECURSIVE_ENTITY_REF"
   "XML_ERROR_ASYNC_ENTITY" "XML_ERROR_BAD_CHAR_REF"
   "XML_ERROR_BINARY_ENTITY_REF"
   "XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF"
   "XML_ERROR_MISPLACED_XML_PI" "XML_ERROR_UNKNOWN_ENCODING"
   "XML_ERROR_INCORRECT_ENCODING"
   "XML_ERROR_UNCLOSED_CDATA_SECTION"
   "XML_ERROR_EXTERNAL_ENTITY_HANDLING" "XML_OPTION_CASE_FOLDING"
   "XML_OPTION_TARGET_ENCODING" "XML_OPTION_SKIP_TAGSTART"
   "XML_OPTION_SKIP_WHITE" "YPERR_BADARGS" "YPERR_BADDB"
   "YPERR_BUSY" "YPERR_DOMAIN" "YPERR_KEY" "YPERR_MAP"
   "YPERR_NODOM" "YPERR_NOMORE" "YPERR_PMAP" "YPERR_RESRC"
   "YPERR_RPC" "YPERR_YPBIND" "YPERR_YPERR" "YPERR_YPSERV"
   "YPERR_VERS" "FORCE_GZIP" "FORCE_DEFLATE"

   ;;PEAR constants
   "PEAR_ERROR_RETURN" "PEAR_ERROR_PRINT" "PEAR_ERROR_TRIGGER"
   "PEAR_ERROR_DIE" "PEAR_ERROR_CALLBACK" "OS_WINDOWS" "OS_UNIX"
   "PEAR_OS" "DB_OK" "DB_ERROR" "DB_ERROR_SYNTAX"
   "DB_ERROR_CONSTRAINT" "DB_ERROR_NOT_FOUND"
   "DB_ERROR_ALREADY_EXISTS" "DB_ERROR_UNSUPPORTED"
   "DB_ERROR_MISMATCH" "DB_ERROR_INVALID" "DB_ERROR_NOT_CAPABLE"
   "DB_ERROR_TRUNCATED" "DB_ERROR_INVALID_NUMBER"
   "DB_ERROR_INVALID_DATE" "DB_ERROR_DIVZERO"
   "DB_ERROR_NODBSELECTED" "DB_ERROR_CANNOT_CREATE"
   "DB_ERROR_CANNOT_DELETE" "DB_ERROR_CANNOT_DROP"
   "DB_ERROR_NOSUCHTABLE" "DB_ERROR_NOSUCHFIELD"
   "DB_ERROR_NEED_MORE_DATA" "DB_ERROR_NOT_LOCKED"
   "DB_ERROR_VALUE_COUNT_ON_ROW" "DB_ERROR_INVALID_DSN"
   "DB_ERROR_CONNECT_FAILED" "DB_WARNING" "DB_WARNING_READ_ONLY"
   "DB_PARAM_SCALAR" "DB_PARAM_OPAQUE" "DB_BINMODE_PASSTHRU"
   "DB_BINMODE_RETURN" "DB_BINMODE_CONVERT" "DB_FETCHMODE_DEFAULT"
   "DB_FETCHMODE_ORDERED" "DB_FETCHMODE_ASSOC"
   "DB_FETCHMODE_FLIPPED" "DB_GETMODE_ORDERED" "DB_GETMODE_ASSOC"
   "DB_GETMODE_FLIPPED" "DB_TABLEINFO_ORDER"
   "DB_TABLEINFO_ORDERTABLE" "DB_TABLEINFO_FULL"

   ;; merged from autocompletion-php.el
   "ERA" "M_E" "M_PI" "NOSTR" "T_FMT" "D_FMT" "MON_9" "MON_8" "MON_7" "MON_6" "MON_5" "MON_4" "MON_3" "MON_2" "MON_1" "DAY_7" "DAY_6" "DAY_5" "DAY_4" "DAY_3" "DAY_2" "DAY_1" "M_LN2" "E_ALL" "YESSTR" "NOEXPR" "PM_STR" "AM_STR" "MON_12" "MON_11" "MON_10" "LC_ALL" "M_2_PI" "M_1_PI" "M_PI_4" "M_PI_2" "M_LN10" "PHP_OS" "LOG_PID" "LOG_LPR" "LOG_ERR" "CODESET" "YESEXPR" "THOUSEP" "D_T_FMT" "ABMON_9" "ABMON_8" "ABMON_7" "ABMON_6" "ABMON_5" "ABMON_4" "ABMON_3" "ABMON_2" "ABMON_1" "ABDAY_7" "ABDAY_6" "ABDAY_5" "ABDAY_4" "ABDAY_3" "ABDAY_2" "ABDAY_1" "LC_TIME" "LOCK_NB" "LOCK_UN" "LOCK_EX" "LOCK_SH" "M_SQRT2" "M_LOG2E" "INI_ALL" "E_PARSE" "E_ERROR" "PHP_EOL" "PHP_ZTS" "LOG_CONS" "LOG_CRON" "LOG_UUCP" "LOG_NEWS" "LOG_AUTH" "LOG_MAIL" "LOG_USER" "LOG_KERN" "LOG_INFO" "LOG_CRIT" "GROUPING" "CRNCYSTR" "ERA_YEAR" "ABMON_12" "ABMON_11" "ABMON_10" "LC_CTYPE" "CHAR_MAX" "INFO_ALL" "SEEK_END" "SEEK_CUR" "SEEK_SET" "M_LOG10E" "INI_USER" "SORT_ASC" "E_STRICT" "E_NOTICE" "PHP_SAPI" "LOG_DEBUG" "LOG_ALERT" "LOG_EMERG" "RADIXCHAR" "ERA_T_FMT" "ERA_D_FMT" "CRYPT_MD5" "M_SQRT1_2" "SORT_DESC" "EXTR_SKIP" "E_WARNING" "PHP_DEBUG" "LOG_NOWAIT" "LOG_NDELAY" "LOG_ODELAY" "LOG_LOCAL7" "LOG_LOCAL6" "LOG_LOCAL5" "LOG_LOCAL4" "LOG_LOCAL3" "LOG_LOCAL2" "LOG_LOCAL1" "LOG_LOCAL0" "LOG_SYSLOG" "LOG_DAEMON" "LOG_NOTICE" "ALT_DIGITS" "T_FMT_AMPM" "LC_COLLATE" "LC_NUMERIC" "CREDITS_QA" "ENT_QUOTES" "ENT_COMPAT" "M_2_SQRTPI" "INI_SYSTEM" "INI_PERDIR" "CASE_UPPER" "CASE_LOWER" "PHP_LIBDIR" "PHP_BINDIR" "PHP_PREFIX" "LOG_WARNING" "N_SIGN_POSN" "P_SIGN_POSN" "FRAC_DIGITS" "ERA_D_T_FMT" "LC_MESSAGES" "LC_MONETARY" "CREDITS_ALL" "ASSERT_BAIL" "SORT_STRING" "PHP_DATADIR" "PHP_INT_MAX" "PHP_VERSION" "LOG_AUTHPRIV" "MON_GROUPING" "STR_PAD_BOTH" "STR_PAD_LEFT" "CREDITS_DOCS" "CREDITS_SAPI" "INFO_LICENSE" "INFO_MODULES" "INFO_CREDITS" "INFO_GENERAL" "ENT_NOQUOTES" "COUNT_NORMAL" "SORT_NUMERIC" "SORT_REGULAR" "E_USER_ERROR" "E_CORE_ERROR" "PHP_INT_SIZE" "THOUSANDS_SEP" "DECIMAL_POINT" "N_CS_PRECEDES" "P_CS_PRECEDES" "NEGATIVE_SIGN" "POSITIVE_SIGN" "STR_PAD_RIGHT" "CREDITS_GROUP" "HTML_ENTITIES" "CRYPT_EXT_DES" "CRYPT_STD_DES" "ASSERT_ACTIVE" "E_USER_NOTICE" "N_SEP_BY_SPACE" "P_SEP_BY_SPACE" "PATH_SEPARATOR" "INFO_VARIABLES" "CRYPT_BLOWFISH" "ASSERT_WARNING" "EXTR_IF_EXISTS" "EXTR_OVERWRITE" "E_USER_WARNING" "E_CORE_WARNING" "PHP_SYSCONFDIR" "PHP_VERSION_ID" "INT_FRAC_DIGITS" "CURRENCY_SYMBOL" "INT_CURR_SYMBOL" "CREDITS_MODULES" "CREDITS_GENERAL" "ASSERT_CALLBACK" "COUNT_RECURSIVE" "EXTR_PREFIX_ALL" "E_COMPILE_ERROR" "PATHINFO_DIRNAME" "CREDITS_FULLPAGE" "INFO_ENVIRONMENT" "EXTR_PREFIX_SAME" "PHP_SHLIB_SUFFIX" "PEAR_INSTALL_DIR" "MON_THOUSANDS_SEP" "MON_DECIMAL_POINT" "PATHINFO_BASENAME" "HTML_SPECIALCHARS" "CRYPT_SALT_LENGTH" "CONNECTION_NORMAL" "ASSERT_QUIET_EVAL" "E_COMPILE_WARNING" "PHP_LOCALSTATEDIR" "PHP_EXTENSION_DIR" "PHP_EXTRA_VERSION" "PHP_MINOR_VERSION" "PHP_MAJOR_VERSION" "PATHINFO_EXTENSION" "INFO_CONFIGURATION" "CONNECTION_TIMEOUT" "CONNECTION_ABORTED" "PEAR_EXTENSION_DIR" "DIRECTORY_SEPARATOR" "EXTR_PREFIX_INVALID" "PHP_RELEASE_VERSION" "PHP_CONFIG_FILE_PATH" "DEFAULT_INCLUDE_PATH" "EXTR_PREFIX_IF_EXISTS" "PHP_OUTPUT_HANDLER_END" "PHP_OUTPUT_HANDLER_CONT" "__COMPILER_HALT_OFFSET__" "PHP_OUTPUT_HANDLER_START" "PHP_CONFIG_FILE_SCAN_DIR"
   "__DIR__"
   ))

(phpcmp-db-update
 'keywords
 '("and" "as" "break" "continue" "declare" "do" "echo" "else" "elseif"
   "endfor" "endforeach" "endif" "endswitch" "endwhile" "exit"
   "extends" "for" "foreach" "global" "if" "include" "include_once"
   "next" "or" "require" "require_once" "return" "static" "switch"
   "then" "var" "while" "xor" "private" "throw" "catch" "try"
   "instanceof" "catch all" "finally"

   ;; merged from autocompletion-php.el
   "die" "use" "new" "list" "eval" "this" "goto" "case" "isset" "empty" "final" "const" "clone" "class" "array" "public" "__DIR__" "default" "__FILE__" "function" "abstract" "__CLASS__" "protected" "namespace" "interface" "cfunction" "__METHOD__" "implements" "enddeclare" "__FUNCTION__" "old_function" "__NAMESPACE__"
   ))

(phpcmp-db-update
 'superglobals
 '("$_GET" "$_POST" "$_COOKIE" "$_SESSION" "$_ENV" "$GLOBALS"
   "$_SERVER" "$_FILES" "$_REQUEST"))

(phpcmp-db-update
 'types
 '("array" "bool" "boolean" "char" "const" "double" "float"
   "int" "integer" "long" "mixed" "object" "real"
   "string"))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Mode ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(define-minor-mode php-completion-mode
  "php-completion mode"
  :lighter phpcmp-lighter
  :group 'php-completion
  (phpcmp-async-set-functions))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; showtip ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; below is copied from showtip.el.
;; I just added prefix(phpcmp-) for name space problem.
;; why?, for portability

;; showtip.el is written by Ye Wenbin.
;; http://www.emacswiki.org/emacs/showtip.el


(defgroup phpcmp-showtip nil
  "Customization group for phpcmp-showtip"
  :group 'help)

(defcustom phpcmp-showtip-timeout 10
  "Seconds to wait before displaying a tooltip the first time."
  :type 'number
  :group 'phpcmp-showtip)

(defcustom phpcmp-showtip-top-adjust 40
  "Basic adjust."
  :type 'number
  :group 'phpcmp-showtip)

(defface phpcmp-showtip-face '((((class color)) :inherit tooltip))
  "face to display items"
  :group 'phpcmp-showtip)

(defun phpcmp-showtip-frame-posn-at-point (&optional position window)
  "Return pixel position of top left corner of glyph at POSITION,
relative to top left corner of frame containing WINDOW. Defaults
to the position of point in the selected window."
  (unless window (setq window (selected-window)))
  (unless position (setq position (window-point window)))
  (let ((x-y (posn-x-y (posn-at-point position window)))
        (edges (window-inside-pixel-edges window)))
    (cons (+ (car x-y) (car  edges))
          (+ (cdr x-y) (cadr edges)))))

(defun phpcmp-showtip (text)
  "Show tooltip text near cursor."
  (let ((pos (phpcmp-showtip-frame-posn-at-point))
        (fg (face-attribute 'phpcmp-showtip-face :foreground nil 'tooltip))
        (bg (face-attribute 'phpcmp-showtip-face :background nil 'tooltip))
        (params tooltip-frame-parameters)
        (top-adjust (- (+ (if menu-bar-mode 25 0)
                          (if tool-bar-mode 35 0)
                          phpcmp-showtip-top-adjust)
                       (if header-line-format
                           (frame-char-height) 0)))
        (max-width 84)
        (max-height 30)
        (frame-height (frame-pixel-height))
        (frame-width (frame-pixel-width))
        (lines (split-string text "\n"))
        width height left top)
    (setq height (* (frame-char-height) (min max-height (length lines))))
    (setq lines (nbutlast lines (- (length lines) (min max-height (length lines)))))
    (setq width (* (frame-char-width)
                   (min max-width (apply 'max (mapcar 'string-width lines)))))
    (setq left (+ (frame-parameter nil 'left) (frame-char-width))
          top (frame-parameter nil 'top))
    ;; if the cursor is at near the right frame fringe or at bottom
    ;; of the bottom fringe, move the frame to
    ;; -frame-width or -frame-height from right or bottom
    (if (< (- frame-width (car pos)) width)
        (setq left (+ left (max 0 (- frame-width width))))
      (setq left (+ left (car pos))))
    (if (< (- frame-height (+ (cdr pos) top-adjust)) height)
        (setq top (+ top frame-height (- height)))
      (setq top (+ top (cdr pos))))
    (setq top (+ top top-adjust))
    (when (stringp fg)
      (setq params (append params `((foreground-color . ,fg)
                                    (border-color . ,fg)))))
    (when (stringp bg)
      (setq params (append params `((background-color . ,bg)))))
    (setq params (append params `((left . ,left)
                                  (top . ,top))))
    (x-show-tip (propertize text 'face 'phpcmp-showtip-face)
                (selected-frame) params phpcmp-showtip-timeout)))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Test ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defmacro phpcmp-with-php-buffer (s &rest body)
  `(with-temp-buffer
     (php-mode)
     (insert ,s)
     (goto-char (point-min))
     (when (re-search-forward (rx "`!!'") nil t)
       (replace-match ""))
     (progn
       ,@body)))


(defun phpcmp-t-to-bool (o)
  (null (null o)))

(dont-compile
  (when (fboundp 'expectations)
    (expectations
      (desc "phpcmp-re-sort-table")
      (expect "constants"
        (first
         (first
          (phpcmp-re-sort-table "constants" (phpcmp-completions-table)))))
      (expect t
        (let* ((tbl (phpcmp-re-sort-table '("global" "superglobals") (phpcmp-completions-table)))
               (first (first (first tbl)))
               (second (first (second  tbl))))
          (and (equal first "superglobals")
               (equal second "global tags"))))
      (desc "phpcmp-take-same-indent-string")
      (expect "class AdminController extends Zend_Controller_ActionAdminController 22,556
  public function init()init 35,1051
"
        (phpcmp-with-php-buffer 
         "`!!'class AdminController extends Zend_Controller_ActionAdminController 22,556
  public function init()init 35,1051
function"
         (phpcmp-take-same-indent-string)))
      (desc "phpcmp-db-get")
      (desc "db-get functions")
      (expect t
        (phpcmp-t-to-bool
         (member "array_map"
                 (phpcmp-db-get 'functions))))
      (desc "db-get ini-directives")
      (expect t
        (phpcmp-t-to-bool
         (member "register_globals"
                 (phpcmp-db-get 'ini-directives))))
      (desc "db-get constants")
      (expect t
        (phpcmp-t-to-bool
         (member "__LINE__"
                 (phpcmp-db-get 'constants))))
      (desc "db-get keywords")
      (expect t
        (phpcmp-t-to-bool
         (member "elseif"
                 (phpcmp-db-get 'keywords))))
      (desc "db-get superglobals")
      (expect t
        (phpcmp-t-to-bool
         (member "$_GET"
                 (phpcmp-db-get 'superglobals))))
      (desc "db-get types")
      (expect t
        (phpcmp-t-to-bool
         (member "array"
                 (phpcmp-db-get 'types))))
      (desc "--- auto-complete.el ---")
      (desc "phpcmp-ac-get-cands")
      (expect t
        (let ((los (phpcmp-ac-get-cands)))
          (and
           (listp los)
           (stringp (first los))
           (stringp (first (last los))))))

      (desc "phpcmp-db-update remove duplicates")
      (expect t
        (phpcmp-db-update '__test-los '("a" "b"))
        (phpcmp-db-update '__test-los '("a" "c"))
        (equal (phpcmp-db-get '__test-los)
               '("c" "a" "b")))
        

      (desc "phpcmp-smart-sort")
      (expect "Class"
        (phpcmp-with-php-buffer
         "Class::func`!!'"
         (phpcmp-smart-sort-rule-full-name)))

      (desc "phpcmp-get-words-in-buffer")
      (expect '("test1" "test2" "test3" "test4")
        (phpcmp-with-php-buffer
         "test1\n test2\n `!!' test3\n test4"
         (phpcmp-get-words-in-buffer)))

      (desc "phpcmp-etags-parse-tags-buffer")
      (expect t

        (let ((tags (phpcmp-with-php-buffer
                     "class OS_GuessOS_Guess 100,3447
    function OS_Guess($uname = null)OS_Guess 108,3550
 
class SimpleCRUDSimpleCRUD 64,1683
     * $gdClient - Client class used to communicate with the Blogger serviceused 74,1824
    public function __construct($email, $password)__construct 89,2249
"
                     (phpcmp-etags-parse-tags-buffer "dummy"))))
          (and (phpcmp-tag-p (first tags))
               (phpcmp-tag-p (second tags)))))

      (expect '(("$notEmpty" . "Zend_Validate_NotEmpty"))
        (phpcmp-with-php-buffer
         "$notEmpty = new Zend_Validate_NotEmpty();"
         (phpcmp-get-obj-instance-of-module-maybe-alist)))
      (expect nil
        (phpcmp-with-php-buffer
         "$var`!!"
         (phpcmp-smart-sort-variable)))

      )))

(provide 'php-completion)

;; php-completion.el ends here.
